/* ----------------------------------------------------------------------------
 * 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("frame_started"), 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("frame_rendering_queued"), 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("frame_ended"), 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("pre_render_target_update"), 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("post_render_target_update"), 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("pre_viewport_update"), 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("post_viewport_update"), 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("viewport_added"), 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("viewport_removed"), 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("pre_render_queues"), 0, NULL);
}


void SwigDirector_RenderQueueListener::postRenderQueues() {
  VALUE result;
  
  result = rb_funcall(swig_get_self(), rb_intern("post_render_queues"), 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("render_queue_started"), 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("render_queue_ended"), 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("prequeue_movable_object_lod_changed"), 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("postqueue_movable_object_lod_changed"), 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("prequeue_entity_mesh_lod_changed"), 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("postqueue_entity_mesh_lod_changed"), 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("prequeue_entity_material_lod_changed"), 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("postqueue_entity_material_lod_changed"), 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("notify_render_single_object"), 5,obj0,obj1,obj2,obj3,obj4);
}



/*
  Document-class: Ogre::Intp

  Proxy of C++ Ogre::Intp class


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


/*
  Document-method: Ogre::Intp.new

  call-seq:
    Intp.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Intp *)new_Intp();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::Intp.assign

  call-seq:
    assign(int value)

An instance method.

*/
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);
  {
    try {
      Intp_assign(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Intp.value

  call-seq:
    value -> int

An instance method.

*/
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);
  {
    try {
      result = (int)Intp_value(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Intp.cast

  call-seq:
    cast -> int

An instance method.

*/
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);
  {
    try {
      result = (int *)Intp_cast(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Intp.frompointer

  call-seq:
    frompointer(int t) -> Intp

A class method.

*/
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);
  {
    try {
      result = (Intp *)Intp_frompointer(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Intp, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::GCVALUE

  Proxy of C++ Ogre::GCVALUE class


*/
swig_class SwigClassGCVALUE;


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

  call-seq:
    inspect -> VALUE

Inspect class and its contents.
*/
SWIGINTERN VALUE
_wrap_GCVALUE_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;
  {
    try {
      result = (VALUE)((swig::GC_VALUE const *)arg1)->inspect();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = result;
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    to_s -> VALUE

Convert class to a String representation.
*/
SWIGINTERN VALUE
_wrap_GCVALUE_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;
  {
    try {
      result = (VALUE)((swig::GC_VALUE const *)arg1)->to_s();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = result;
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ConstIterator

  Proxy of C++ Ogre::ConstIterator class


*/
swig_class SwigClassConstIterator;

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


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

  call-seq:
    value -> VALUE

An instance method.

*/
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 {
      try {
        result = (VALUE)((swig::ConstIterator const *)arg1)->value();
      }
      catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_Ruby_ExceptionType(NULL, Qnil);
          SWIG_fail;
        }
      }
      
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (swig::ConstIterator *)((swig::ConstIterator const *)arg1)->dup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (VALUE)((swig::ConstIterator const *)arg1)->inspect();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (VALUE)((swig::ConstIterator const *)arg1)->to_s();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = result;
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    next(size_t n=1) -> ConstIterator
    next -> ConstIterator

An instance method.

*/
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);
  {
    try {
      result = (swig::ConstIterator *)(arg1)->next(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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 {
      try {
        result = (swig::ConstIterator *)(arg1)->next();
      }
      catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_Ruby_ExceptionType(NULL, Qnil);
          SWIG_fail;
        }
      }
      
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



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

  call-seq:
    previous(size_t n=1) -> ConstIterator
    previous -> ConstIterator

An instance method.

*/
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);
  {
    try {
      result = (swig::ConstIterator *)(arg1)->previous(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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 {
      try {
        result = (swig::ConstIterator *)(arg1)->previous();
      }
      catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_Ruby_ExceptionType(NULL, Qnil);
          SWIG_fail;
        }
      }
      
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (bool)((swig::ConstIterator const *)arg1)->operator ==((swig::ConstIterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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 {
      try {
        result = (swig::ConstIterator *)((swig::ConstIterator const *)arg1)->operator +(arg2);
      }
      catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_Ruby_ExceptionType(NULL, Qnil);
          SWIG_fail;
        }
      }
      
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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 {
      try {
        result = (swig::ConstIterator *)((swig::ConstIterator const *)arg1)->operator -(arg2);
      }
      catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_Ruby_ExceptionType(NULL, Qnil);
          SWIG_fail;
        }
      }
      
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = ((swig::ConstIterator const *)arg1)->operator -((swig::ConstIterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
}



/*
  Document-class: Ogre::Iterator < Ogre::swig::ConstIterator

  Proxy of C++ Ogre::Iterator class


*/
swig_class SwigClassIterator;


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

  call-seq:
    value=(VALUE v) -> VALUE

An instance method.

*/
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;
  {
    try {
      result = (VALUE)(arg1)->setValue((VALUE const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (swig::Iterator *)((swig::Iterator const *)arg1)->dup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    next(size_t n=1) -> Iterator
    next -> Iterator

An instance method.

*/
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);
  {
    try {
      result = (swig::Iterator *)(arg1)->next(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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 {
      try {
        result = (swig::Iterator *)(arg1)->next();
      }
      catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_Ruby_ExceptionType(NULL, Qnil);
          SWIG_fail;
        }
      }
      
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



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

  call-seq:
    previous(size_t n=1) -> Iterator
    previous -> Iterator

An instance method.

*/
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);
  {
    try {
      result = (swig::Iterator *)(arg1)->previous(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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 {
      try {
        result = (swig::Iterator *)(arg1)->previous();
      }
      catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_Ruby_ExceptionType(NULL, Qnil);
          SWIG_fail;
        }
      }
      
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (VALUE)((swig::Iterator const *)arg1)->inspect();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (VALUE)((swig::Iterator const *)arg1)->to_s();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (bool)((swig::Iterator const *)arg1)->operator ==((swig::Iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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 {
      try {
        result = (swig::Iterator *)((swig::Iterator const *)arg1)->operator +(arg2);
      }
      catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_Ruby_ExceptionType(NULL, Qnil);
          SWIG_fail;
        }
      }
      
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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 {
      try {
        result = (swig::Iterator *)((swig::Iterator const *)arg1)->operator -(arg2);
      }
      catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_Ruby_ExceptionType(NULL, Qnil);
          SWIG_fail;
        }
      }
      
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = ((swig::Iterator const *)arg1)->operator -((swig::Iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
}


/*
  Document-class: Ogre::VertexBoneAssignmentS

  Proxy of C++ Ogre::VertexBoneAssignmentS class


*/
swig_class SwigClassVertexBoneAssignmentS;


/*
  Document-method: Ogre::VertexBoneAssignmentS.vertexIndex

  call-seq:
    vertexIndex -> unsigned int

Get value of attribute.

*/

/*
  Document-method: Ogre::VertexBoneAssignmentS.vertexIndex=

  call-seq:
    vertexIndex=(x) -> unsigned int

Set new value for attribute.

*/
SWIGINTERN VALUE
_wrap_VertexBoneAssignmentS_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_VertexBoneAssignmentS_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;
}



/*
  Document-method: Ogre::VertexBoneAssignmentS.boneIndex

  call-seq:
    boneIndex -> unsigned short

Get value of attribute.

*/

/*
  Document-method: Ogre::VertexBoneAssignmentS.boneIndex=

  call-seq:
    boneIndex=(x) -> unsigned short

Set new value for attribute.

*/
SWIGINTERN VALUE
_wrap_VertexBoneAssignmentS_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_VertexBoneAssignmentS_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;
}



/*
  Document-method: Ogre::VertexBoneAssignmentS.weight

  call-seq:
    weight -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::VertexBoneAssignmentS.weight=

  call-seq:
    weight=(x) -> Real

Set new value for attribute.

*/
SWIGINTERN VALUE
_wrap_VertexBoneAssignmentS_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_VertexBoneAssignmentS_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_VertexBoneAssignmentS_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_VertexBoneAssignmentS_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;
  }
  


/*
  Document-method: Ogre::VertexBoneAssignmentS.new

  call-seq:
    VertexBoneAssignmentS.new

Class constructor.

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


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


/*
  Document-class: Ogre::AlignedMemory

  Proxy of C++ Ogre::AlignedMemory class


*/
swig_class SwigClassAlignedMemory;


/*
  Document-method: Ogre::AlignedMemory.deallocate

  call-seq:
    deallocate(void p)

A class method.

*/
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] )); 
  }
  {
    try {
      Ogre::AlignedMemory::deallocate(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::AlignedMemory.new

  call-seq:
    AlignedMemory.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::AlignedMemory *)new Ogre::AlignedMemory();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


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


/*
  Document-class: Ogre::Radian

  Proxy of C++ Ogre::Radian class


*/
swig_class SwigClassRadian;


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

  call-seq:
    Radian.new(Real r=0)
    Radian.new
    Radian.new(Degree d)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Radian *)new Ogre::Radian(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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;
  }
  {
    try {
      result = (Ogre::Radian *)new Ogre::Radian();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Radian *)new Ogre::Radian((Ogre::Degree const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



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

  call-seq:
    value_degrees -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Radian_value_degrees(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Radian const *)arg1)->valueDegrees();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    value_radians -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Radian_value_radians(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Radian const *)arg1)->valueRadians();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    value_angle_units -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Radian_value_angle_units(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Radian const *)arg1)->valueAngleUnits();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (Ogre::Radian *) &((Ogre::Radian const *)arg1)->operator +();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      result = ((Ogre::Radian const *)arg1)->operator +((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = ((Ogre::Radian const *)arg1)->operator +((Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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);
  {
    try {
      result = ((Ogre::Radian const *)arg1)->operator -();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::Radian const *)arg1)->operator -((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = ((Ogre::Radian const *)arg1)->operator -((Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



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

  call-seq:
    *(Real f) -> Radian
    *(Radian f) -> Radian

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Radian const *)arg1)->operator *(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = ((Ogre::Radian const *)arg1)->operator *((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



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

  call-seq:
    /(Real f) -> Radian

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Radian const *)arg1)->operator /(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Radian const *)arg1)->operator <((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Radian const *)arg1)->operator <=((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Radian const *)arg1)->operator ==((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Radian const *)arg1)->operator >=((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Radian const *)arg1)->operator >((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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


/*
  Document-class: Ogre::Degree

  Proxy of C++ Ogre::Degree class


*/
swig_class SwigClassDegree;


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

  call-seq:
    Degree.new(Real d=0)
    Degree.new
    Degree.new(Radian r)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Degree *)new Ogre::Degree(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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;
  }
  {
    try {
      result = (Ogre::Degree *)new Ogre::Degree();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Degree *)new Ogre::Degree((Ogre::Radian const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



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

  call-seq:
    value_degrees -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Degree_value_degrees(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Degree const *)arg1)->valueDegrees();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    value_radians -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Degree_value_radians(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Degree const *)arg1)->valueRadians();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    value_angle_units -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Degree_value_angle_units(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Degree const *)arg1)->valueAngleUnits();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (Ogre::Degree *) &((Ogre::Degree const *)arg1)->operator +();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      result = ((Ogre::Degree const *)arg1)->operator +((Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Degree const *)arg1)->operator +((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Degree const *)arg1)->operator -();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Degree const *)arg1)->operator -((Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Degree const *)arg1)->operator -((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



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

  call-seq:
    *(Real f) -> Degree
    *(Degree f) -> Degree

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Degree const *)arg1)->operator *(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Degree const *)arg1)->operator *((Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



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

  call-seq:
    /(Real f) -> Degree

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Degree const *)arg1)->operator /(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (bool)((Ogre::Degree const *)arg1)->operator <((Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Degree const *)arg1)->operator <=((Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Degree const *)arg1)->operator ==((Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Degree const *)arg1)->operator >=((Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Degree const *)arg1)->operator >((Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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


/*
  Document-class: Ogre::Angle

  Proxy of C++ Ogre::Angle class


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


/*
  Document-method: Ogre::Angle.new

  call-seq:
    Angle.new(Real angle)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Angle *)new Ogre::Angle(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


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


/*
  Document-class: Ogre::Math

  Proxy of C++ Ogre::Math class


*/
swig_class SwigClassMath;


/*
  Document-method: Ogre::AngleUnit.AU_DEGREE

  call-seq:
    AU_DEGREE -> int

A class method.

*/

/*
  Document-method: Ogre::AngleUnit.AU_RADIAN

  call-seq:
    AU_RADIAN -> int

A class method.

*/

/*
  Document-method: Ogre::Math.new

  call-seq:
    Math.new(unsigned int trigTableSize=4096)
    Math.new

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Math *)new Ogre::Math(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      result = (Ogre::Math *)new Ogre::Math();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::Math.iabs

  call-seq:
    iabs(int iValue) -> int

A class method.

*/
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);
  {
    try {
      result = (int)Ogre::Math::IAbs(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.iceil

  call-seq:
    iceil(float fValue) -> int

A class method.

*/
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);
  {
    try {
      result = (int)Ogre::Math::ICeil(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.ifloor

  call-seq:
    ifloor(float fValue) -> int

A class method.

*/
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);
  {
    try {
      result = (int)Ogre::Math::IFloor(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.isign

  call-seq:
    isign(int iValue) -> int

A class method.

*/
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);
  {
    try {
      result = (int)Ogre::Math::ISign(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.abs

  call-seq:
    abs(Real fValue) -> Real
    abs(Degree dValue) -> Degree
    abs(Radian rValue) -> Radian

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Abs(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = Ogre::Math::Abs((Ogre::Degree const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = Ogre::Math::Abs((Ogre::Radian const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Math.acos

  call-seq:
    acos(Real fValue) -> Radian

A class method.

*/
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);
  {
    try {
      result = Ogre::Math::ACos(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.asin

  call-seq:
    asin(Real fValue) -> Radian

A class method.

*/
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);
  {
    try {
      result = Ogre::Math::ASin(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.atan

  call-seq:
    atan(Real fValue) -> Radian

A class method.

*/
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);
  {
    try {
      result = Ogre::Math::ATan(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.atan2

  call-seq:
    atan2(Real fY, Real fX) -> Radian

A class method.

*/
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);
  {
    try {
      result = Ogre::Math::ATan2(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.ceil

  call-seq:
    ceil(Real fValue) -> Real

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Ceil(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.is_na_n

  call-seq:
    is_na_n(Real f) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_is_na_n(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);
  {
    try {
      result = (bool)Ogre::Math::isNaN(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.cos

  call-seq:
    cos(Radian fValue, bool useTables=false) -> Real
    cos(Radian fValue) -> Real
    cos(Real fValue, bool useTables=false) -> Real
    cos(Real fValue) -> Real

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Cos((Ogre::Radian const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Cos((Ogre::Radian const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Cos(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Cos(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
}



/*
  Document-method: Ogre::Math.exp

  call-seq:
    exp(Real fValue) -> Real

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Exp(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.floor

  call-seq:
    floor(Real fValue) -> Real

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Floor(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.log

  call-seq:
    log(Real fValue) -> Real

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Log(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.LOG2

  call-seq:
    LOG2 -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Math.Math_LOG2

  call-seq:
    Math_LOG2 -> Real

Get value of attribute.

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



/*
  Document-method: Ogre::Math.log2

  call-seq:
    log2(Real fValue) -> Real

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Log2(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.log_n

  call-seq:
    log_n(Real base, Real fValue) -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_log_n(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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::LogN(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.pow

  call-seq:
    pow(Real fBase, Real fExponent) -> Real

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Pow(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.sign

  call-seq:
    sign(Real fValue) -> Real
    sign(Radian rValue) -> Radian
    sign(Degree dValue) -> Degree

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Sign(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = Ogre::Math::Sign((Ogre::Radian const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = Ogre::Math::Sign((Ogre::Degree const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Math.sin

  call-seq:
    sin(Radian fValue, bool useTables=false) -> Real
    sin(Radian fValue) -> Real
    sin(Real fValue, bool useTables=false) -> Real
    sin(Real fValue) -> Real

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Sin((Ogre::Radian const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Sin((Ogre::Radian const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Sin(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Sin(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
}



/*
  Document-method: Ogre::Math.sqr

  call-seq:
    sqr(Real fValue) -> Real

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Sqr(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.sqrt

  call-seq:
    sqrt(Real fValue) -> Real
    sqrt(Radian fValue) -> Radian
    sqrt(Degree fValue) -> Degree

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Sqrt(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = Ogre::Math::Sqrt((Ogre::Radian const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = Ogre::Math::Sqrt((Ogre::Degree const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Math.inv_sqrt

  call-seq:
    inv_sqrt(Real fValue) -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_inv_sqrt(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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::InvSqrt(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.unit_random

  call-seq:
    unit_random -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_unit_random(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;
  }
  {
    try {
      result = (Ogre::Real)Ogre::Math::UnitRandom();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.range_random

  call-seq:
    range_random(Real fLow, Real fHigh) -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_range_random(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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::RangeRandom(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.symmetric_random

  call-seq:
    symmetric_random -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_symmetric_random(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;
  }
  {
    try {
      result = (Ogre::Real)Ogre::Math::SymmetricRandom();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.tan

  call-seq:
    tan(Radian fValue, bool useTables=false) -> Real
    tan(Radian fValue) -> Real
    tan(Real fValue, bool useTables=false) -> Real
    tan(Real fValue) -> Real

A class method.

*/
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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Tan((Ogre::Radian const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Tan((Ogre::Radian const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Tan(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::Tan(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
}



/*
  Document-method: Ogre::Math.degrees_to_radians

  call-seq:
    degrees_to_radians(Real degrees) -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_degrees_to_radians(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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::DegreesToRadians(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.radians_to_degrees

  call-seq:
    radians_to_degrees(Real radians) -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_radians_to_degrees(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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::RadiansToDegrees(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.set_angle_unit

  call-seq:
    set_angle_unit(AngleUnit unit)

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_set_angle_unit(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);
  {
    try {
      Ogre::Math::setAngleUnit(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.get_angle_unit

  call-seq:
    get_angle_unit -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_get_angle_unit(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;
  }
  {
    try {
      result = (Ogre::Math::AngleUnit)Ogre::Math::getAngleUnit();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.angle_units_to_radians

  call-seq:
    angle_units_to_radians(Real units) -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_angle_units_to_radians(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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::AngleUnitsToRadians(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.radians_to_angle_units

  call-seq:
    radians_to_angle_units(Real radians) -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_radians_to_angle_units(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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::RadiansToAngleUnits(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.angle_units_to_degrees

  call-seq:
    angle_units_to_degrees(Real units) -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_angle_units_to_degrees(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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::AngleUnitsToDegrees(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.degrees_to_angle_units

  call-seq:
    degrees_to_angle_units(Real degrees) -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_degrees_to_angle_units(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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::DegreesToAngleUnits(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.point_in_tri_2d

  call-seq:
    point_in_tri_2d(Vector2 p, Vector2 a, Vector2 b, Vector2 c) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_point_in_tri_2d(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);
  {
    try {
      result = (bool)Ogre::Math::pointInTri2D((Ogre::Vector2 const &)*arg1,(Ogre::Vector2 const &)*arg2,(Ogre::Vector2 const &)*arg3,(Ogre::Vector2 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.point_in_tri_3d

  call-seq:
    point_in_tri_3d(Vector3 p, Vector3 a, Vector3 b, Vector3 c, Vector3 normal) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_point_in_tri_3d(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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.intersects

  call-seq:
    intersects(Ray ray, Plane plane) -> std::pair<(bool,Ogre::Real)>
    intersects(Ray ray, Sphere sphere, bool discardInside=true) -> std::pair<(bool,Ogre::Real)>
    intersects(Ray ray, Sphere sphere) -> std::pair<(bool,Ogre::Real)>
    intersects(Ray ray, AxisAlignedBox box) -> std::pair<(bool,Ogre::Real)>
    intersects(Ray ray, AxisAlignedBox box, Real d1, Real d2) -> bool
    intersects(Ray ray, Vector3 a, Vector3 b, Vector3 c, Vector3 normal, 
    bool positiveSide=true, bool negativeSide=true) -> std::pair<(bool,Ogre::Real)>
    intersects(Ray ray, Vector3 a, Vector3 b, Vector3 c, Vector3 normal, 
    bool positiveSide=true) -> std::pair<(bool,Ogre::Real)>
    intersects(Ray ray, Vector3 a, Vector3 b, Vector3 c, Vector3 normal) -> std::pair<(bool,Ogre::Real)>
    intersects(Ray ray, Vector3 a, Vector3 b, Vector3 c, bool positiveSide=true, 
    bool negativeSide=true) -> std::pair<(bool,Ogre::Real)>
    intersects(Ray ray, Vector3 a, Vector3 b, Vector3 c, bool positiveSide=true) -> std::pair<(bool,Ogre::Real)>
    intersects(Ray ray, Vector3 a, Vector3 b, Vector3 c) -> std::pair<(bool,Ogre::Real)>
    intersects(Sphere sphere, AxisAlignedBox box) -> bool
    intersects(Plane plane, AxisAlignedBox box) -> bool
    intersects(Ray ray, Ogre::vector<(Ogre::Plane,Ogre::STLAllocator<(Ogre::Plane,Ogre::GeneralAllocPolicy)>)>::type planeList, 
    bool normalIsOutside) -> std::pair<(bool,Ogre::Real)>
    intersects(Ray ray, Ogre::list<(Ogre::Plane,Ogre::STLAllocator<(Ogre::Plane,Ogre::GeneralAllocPolicy)>)>::type planeList, 
    bool normalIsOutside) -> std::pair<(bool,Ogre::Real)>
    intersects(Sphere sphere, Plane plane) -> bool

A class method.

*/
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);
  {
    try {
      result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Plane const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Sphere const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Sphere const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = (bool)Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::AxisAlignedBox const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::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);
  {
    try {
      result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4,(Ogre::Vector3 const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::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);
  {
    try {
      result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = (bool)Ogre::Math::intersects((Ogre::Sphere const &)*arg1,(Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (bool)Ogre::Math::intersects((Ogre::Plane const &)*arg1,(Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::vector< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::list< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = (bool)Ogre::Math::intersects((Ogre::Sphere const &)*arg1,(Ogre::Plane const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Math.real_equal

  call-seq:
    real_equal(Real a, Real b, Real tolerance=std::numeric_limits< Ogre::Real >::epsilon()) -> bool
    real_equal(Real a, Real b) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_real_equal__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);
  {
    try {
      result = (bool)Ogre::Math::RealEqual(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_real_equal__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);
  {
    try {
      result = (bool)Ogre::Math::RealEqual(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Math_real_equal(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_real_equal__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_real_equal__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Math.real_equal", 
    "    bool Math.real_equal(Ogre::Real a, Ogre::Real b, Ogre::Real tolerance)\n"
    "    bool Math.real_equal(Ogre::Real a, Ogre::Real b)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Math.calculate_tangent_space_vector

  call-seq:
    calculate_tangent_space_vector(Vector3 position1, Vector3 position2, Vector3 position3, 
    Real u1, Real v1, Real u2, Real v2, Real u3, 
    Real v3) -> Vector3

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_calculate_tangent_space_vector(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);
  {
    try {
      result = Ogre::Math::calculateTangentSpaceVector((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.build_reflection_matrix

  call-seq:
    build_reflection_matrix(Plane p) -> Matrix4

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_build_reflection_matrix(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);
  {
    try {
      result = Ogre::Math::buildReflectionMatrix((Ogre::Plane const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.calculate_face_normal

  call-seq:
    calculate_face_normal(Vector3 v1, Vector3 v2, Vector3 v3) -> Vector4

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_calculate_face_normal(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);
  {
    try {
      result = Ogre::Math::calculateFaceNormal((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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::Math.calculate_basic_face_normal

  call-seq:
    calculate_basic_face_normal(Vector3 v1, Vector3 v2, Vector3 v3) -> Vector3

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_calculate_basic_face_normal(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);
  {
    try {
      result = Ogre::Math::calculateBasicFaceNormal((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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::Math.calculate_face_normal_without_normalize

  call-seq:
    calculate_face_normal_without_normalize(Vector3 v1, Vector3 v2, Vector3 v3) -> Vector4

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_calculate_face_normal_without_normalize(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);
  {
    try {
      result = Ogre::Math::calculateFaceNormalWithoutNormalize((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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::Math.calculate_basic_face_normal_without_normalize

  call-seq:
    calculate_basic_face_normal_without_normalize(Vector3 v1, Vector3 v2, Vector3 v3) -> Vector3

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_calculate_basic_face_normal_without_normalize(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);
  {
    try {
      result = Ogre::Math::calculateBasicFaceNormalWithoutNormalize((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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::Math.gaussian_distribution

  call-seq:
    gaussian_distribution(Real x, Real offset=0.0, Real scale=1.0) -> Real
    gaussian_distribution(Real x, Real offset=0.0) -> Real
    gaussian_distribution(Real x) -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_gaussian_distribution__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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::gaussianDistribution(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_gaussian_distribution__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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::gaussianDistribution(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_gaussian_distribution__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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::gaussianDistribution(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Math_gaussian_distribution(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_gaussian_distribution__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_gaussian_distribution__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_gaussian_distribution__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Math.gaussian_distribution", 
    "    Ogre::Real Math.gaussian_distribution(Ogre::Real x, Ogre::Real offset, Ogre::Real scale)\n"
    "    Ogre::Real Math.gaussian_distribution(Ogre::Real x, Ogre::Real offset)\n"
    "    Ogre::Real Math.gaussian_distribution(Ogre::Real x)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Math.make_view_matrix

  call-seq:
    make_view_matrix(Vector3 position, Quaternion orientation, Matrix4 reflectMatrix=0) -> Matrix4
    make_view_matrix(Vector3 position, Quaternion orientation) -> Matrix4

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_make_view_matrix__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);
  {
    try {
      result = Ogre::Math::makeViewMatrix((Ogre::Vector3 const &)*arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Matrix4 const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_make_view_matrix__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);
  {
    try {
      result = Ogre::Math::makeViewMatrix((Ogre::Vector3 const &)*arg1,(Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_make_view_matrix(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_make_view_matrix__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_make_view_matrix__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Math.make_view_matrix", 
    "    Ogre::Matrix4 Math.make_view_matrix(Ogre::Vector3 const &position, Ogre::Quaternion const &orientation, Ogre::Matrix4 const *reflectMatrix)\n"
    "    Ogre::Matrix4 Math.make_view_matrix(Ogre::Vector3 const &position, Ogre::Quaternion const &orientation)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Math.bounding_radius_from_aabb

  call-seq:
    bounding_radius_from_aabb(AxisAlignedBox aabb) -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_Math_bounding_radius_from_aabb(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);
  {
    try {
      result = (Ogre::Real)Ogre::Math::boundingRadiusFromAABB((Ogre::AxisAlignedBox const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Math.POS_INFINITY

  call-seq:
    POS_INFINITY -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Math.Math_POS_INFINITY

  call-seq:
    Math_POS_INFINITY -> Real

Get value of attribute.

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



/*
  Document-method: Ogre::Math.NEG_INFINITY

  call-seq:
    NEG_INFINITY -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Math.Math_NEG_INFINITY

  call-seq:
    Math_NEG_INFINITY -> Real

Get value of attribute.

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



/*
  Document-method: Ogre::Math.PI

  call-seq:
    PI -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Math.Math_PI

  call-seq:
    Math_PI -> Real

Get value of attribute.

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



/*
  Document-method: Ogre::Math.TWO_PI

  call-seq:
    TWO_PI -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Math.Math_TWO_PI

  call-seq:
    Math_TWO_PI -> Real

Get value of attribute.

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



/*
  Document-method: Ogre::Math.HALF_PI

  call-seq:
    HALF_PI -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Math.Math_HALF_PI

  call-seq:
    Math_HALF_PI -> Real

Get value of attribute.

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



/*
  Document-method: Ogre::Math.fDeg2Rad

  call-seq:
    fDeg2Rad -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Math.Math_fDeg2Rad

  call-seq:
    Math_fDeg2Rad -> Real

Get value of attribute.

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



/*
  Document-method: Ogre::Math.fRad2Deg

  call-seq:
    fRad2Deg -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Math.Math_fRad2Deg

  call-seq:
    Math_fRad2Deg -> Real

Get value of attribute.

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



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

  call-seq:
    *(Real a, Radian b) -> Radian
    *(Real a, Degree b) -> Degree
    *(Vector4 v, Matrix4 mat) -> Vector4

A module function.

*/
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);
  {
    try {
      result = Ogre::operator *(arg1,(Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    /(Real a, Radian b) -> Radian
    /(Real a, Degree b) -> Degree

A module function.

*/
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);
  {
    try {
      result = Ogre::operator /(arg1,(Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    *(Real a, Radian b) -> Radian
    *(Real a, Degree b) -> Degree
    *(Vector4 v, Matrix4 mat) -> Vector4

A module function.

*/
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);
  {
    try {
      result = Ogre::operator *(arg1,(Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    /(Real a, Radian b) -> Radian
    /(Real a, Degree b) -> Degree

A module function.

*/
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);
  {
    try {
      result = Ogre::operator /(arg1,(Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-class: Ogre::Vector2

  Proxy of C++ Ogre::Vector2 class


*/
swig_class SwigClassVector2;


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

  call-seq:
    x -> Real

Get value of attribute.

*/

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

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

Set new value for attribute.

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



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

  call-seq:
    y -> Real

Get value of attribute.

*/

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

  call-seq:
    y=(x) -> Real

Set new value for attribute.

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



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

  call-seq:
    Vector2.new
    Vector2.new(Real fX, Real fY)
    Vector2.new(Real scaler)
    Vector2.new(Real afCoordinate)
    Vector2.new(int afCoordinate)
    Vector2.new(Real r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Vector2 *)new Ogre::Vector2();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector2 *)new Ogre::Vector2(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector2 *)new Ogre::Vector2(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector2 *)new Ogre::Vector2((Ogre::Real const (*))arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector2 *)new Ogre::Vector2((int const (*))arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Vector2 *)new Ogre::Vector2(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



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

  call-seq:
    swap(Vector2 other)

An instance method.

*/
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);
  {
    try {
      (arg1)->swap(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    ptr -> Real
    ptr -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real *)(arg1)->ptr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Real *)((Ogre::Vector2 const *)arg1)->ptr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (bool)((Ogre::Vector2 const *)arg1)->operator ==((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->operator +((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->operator -((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    *(Real fScalar) -> Vector2
    *(Vector2 rhs) -> Vector2

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->operator *(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->operator *((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



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

  call-seq:
    /(Real fScalar) -> Vector2
    /(Vector2 rhs) -> Vector2

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->operator /(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->operator /((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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);
  {
    try {
      result = (Ogre::Vector2 *) &((Ogre::Vector2 const *)arg1)->operator +();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->operator -();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector2 const *)arg1)->length();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    squared_length -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_squared_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 *","squaredLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector2 const *)arg1)->squaredLength();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    distance(Vector2 rhs) -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector2 const *)arg1)->distance((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    squared_distance(Vector2 rhs) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_squared_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 *","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);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector2 const *)arg1)->squaredDistance((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    dot_product(Vector2 vec) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_dot_product(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector2 const *)arg1)->dotProduct((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    normalise -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)(arg1)->normalise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    mid_point(Vector2 vec) -> Vector2

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_mid_point(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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->midPoint((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Vector2 const *)arg1)->operator <((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Vector2 const *)arg1)->operator >((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    make_floor(Vector2 cmp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_make_floor(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);
  {
    try {
      (arg1)->makeFloor((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    make_ceil(Vector2 cmp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_make_ceil(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);
  {
    try {
      (arg1)->makeCeil((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    perpendicular -> Vector2

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->perpendicular();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    cross_product(Vector2 rkVector) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_cross_product(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector2 const *)arg1)->crossProduct((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    random_deviant(Real angle) -> Vector2

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_random_deviant(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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->randomDeviant(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    is_zero_length -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_is_zero_length(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);
  {
    try {
      result = (bool)((Ogre::Vector2 const *)arg1)->isZeroLength();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    normalised_copy -> Vector2

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_normalised_copy(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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->normalisedCopy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    reflect(Vector2 normal) -> Vector2

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->reflect((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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.is_na_n

  call-seq:
    is_na_n -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_is_na_n(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);
  {
    try {
      result = (bool)((Ogre::Vector2 const *)arg1)->isNaN();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    angle_between(Vector2 other) -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_angle_between(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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->angleBetween((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    angle_to(Vector2 other) -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector2_angle_to(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);
  {
    try {
      result = ((Ogre::Vector2 const *)arg1)->angleTo((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    ZERO -> Vector2

Get value of attribute.

*/

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

  call-seq:
    Vector2_ZERO -> Vector2

Get value of attribute.

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



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

  call-seq:
    UNIT_X -> Vector2

Get value of attribute.

*/

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

  call-seq:
    Vector2_UNIT_X -> Vector2

Get value of attribute.

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



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

  call-seq:
    UNIT_Y -> Vector2

Get value of attribute.

*/

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

  call-seq:
    Vector2_UNIT_Y -> Vector2

Get value of attribute.

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



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

  call-seq:
    NEGATIVE_UNIT_X -> Vector2

Get value of attribute.

*/

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

  call-seq:
    Vector2_NEGATIVE_UNIT_X -> Vector2

Get value of attribute.

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



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

  call-seq:
    NEGATIVE_UNIT_Y -> Vector2

Get value of attribute.

*/

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

  call-seq:
    Vector2_NEGATIVE_UNIT_Y -> Vector2

Get value of attribute.

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



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

  call-seq:
    UNIT_SCALE -> Vector2

Get value of attribute.

*/

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

  call-seq:
    Vector2_UNIT_SCALE -> Vector2

Get value of attribute.

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


/*
  Document-class: Ogre::Quaternion

  Proxy of C++ Ogre::Quaternion class


*/
swig_class SwigClassQuaternion;


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

  call-seq:
    Quaternion.new
    Quaternion.new(Real fW, Real fX, Real fY, Real fZ)
    Quaternion.new(Matrix3 rot)
    Quaternion.new(Radian rfAngle, Vector3 rkAxis)
    Quaternion.new(Vector3 xaxis, Vector3 yaxis, Vector3 zaxis)
    Quaternion.new(Vector3 akAxis)
    Quaternion.new(Real valptr)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Quaternion *)new Ogre::Quaternion();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Quaternion *)new Ogre::Quaternion(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Quaternion *)new Ogre::Quaternion((Ogre::Matrix3 const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Quaternion *)new Ogre::Quaternion((Ogre::Radian const &)*arg1,(Ogre::Vector3 const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Quaternion *)new Ogre::Quaternion((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Quaternion *)new Ogre::Quaternion((Ogre::Vector3 const *)arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Quaternion *)new Ogre::Quaternion(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



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

  call-seq:
    swap(Quaternion other)

An instance method.

*/
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);
  {
    try {
      (arg1)->swap(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    ptr -> Real
    ptr -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real *)(arg1)->ptr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Real *)((Ogre::Quaternion const *)arg1)->ptr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



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

  call-seq:
    from_rotation_matrix(Matrix3 kRot)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_from_rotation_matrix(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);
  {
    try {
      (arg1)->FromRotationMatrix((Ogre::Matrix3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    to_rotation_matrix(Matrix3 kRot)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_to_rotation_matrix(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);
  {
    try {
      ((Ogre::Quaternion const *)arg1)->ToRotationMatrix(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    from_angle_axis(Radian rfAngle, Vector3 rkAxis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_from_angle_axis(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);
  {
    try {
      (arg1)->FromAngleAxis((Ogre::Radian const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    to_angle_axis(Radian rfAngle, Vector3 rkAxis)
    to_angle_axis(Degree dAngle, Vector3 rkAxis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_to_angle_axis__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);
  {
    try {
      ((Ogre::Quaternion const *)arg1)->ToAngleAxis(*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_to_angle_axis__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);
  {
    try {
      ((Ogre::Quaternion const *)arg1)->ToAngleAxis(*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Quaternion_to_angle_axis(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_to_angle_axis__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_to_angle_axis__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Quaternion.to_angle_axis", 
    "    void Quaternion.to_angle_axis(Ogre::Radian &rfAngle, Ogre::Vector3 &rkAxis)\n"
    "    void Quaternion.to_angle_axis(Ogre::Degree &dAngle, Ogre::Vector3 &rkAxis)\n");
  
  return Qnil;
}



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

  call-seq:
    from_axes(Vector3 akAxis)
    from_axes(Vector3 xAxis, Vector3 yAxis, Vector3 zAxis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_from_axes__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);
  {
    try {
      (arg1)->FromAxes((Ogre::Vector3 const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_from_axes__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);
  {
    try {
      (arg1)->FromAxes((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Quaternion_from_axes(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_from_axes__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_from_axes__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Quaternion.from_axes", 
    "    void Quaternion.from_axes(Ogre::Vector3 const *akAxis)\n"
    "    void Quaternion.from_axes(Ogre::Vector3 const &xAxis, Ogre::Vector3 const &yAxis, Ogre::Vector3 const &zAxis)\n");
  
  return Qnil;
}



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

  call-seq:
    to_axes(Vector3 akAxis)
    to_axes(Vector3 xAxis, Vector3 yAxis, Vector3 zAxis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_to_axes__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);
  {
    try {
      ((Ogre::Quaternion const *)arg1)->ToAxes(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_to_axes__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);
  {
    try {
      ((Ogre::Quaternion const *)arg1)->ToAxes(*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Quaternion_to_axes(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_to_axes__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_to_axes__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Quaternion.to_axes", 
    "    void Quaternion.to_axes(Ogre::Vector3 *akAxis)\n"
    "    void Quaternion.to_axes(Ogre::Vector3 &xAxis, Ogre::Vector3 &yAxis, Ogre::Vector3 &zAxis)\n");
  
  return Qnil;
}



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

  call-seq:
    x_axis -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_x_axis(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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->xAxis();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    y_axis -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_y_axis(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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->yAxis();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    z_axis -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_z_axis(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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->zAxis();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->operator +((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->operator -((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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 rkQ) -> Quaternion
    *(Real fScalar) -> Quaternion
    *(Vector3 rkVector) -> Vector3

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->operator *((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->operator *(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->operator -();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Quaternion const *)arg1)->operator ==((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    dot(Quaternion rkQ) -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)((Ogre::Quaternion const *)arg1)->Dot((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    norm -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)((Ogre::Quaternion const *)arg1)->Norm();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    normalise -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)(arg1)->normalise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    inverse -> Quaternion

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->Inverse();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    unit_inverse -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_unit_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 *","UnitInverse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->UnitInverse();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    exp -> Quaternion

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->Exp();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    log -> Quaternion

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->Log();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    *(Quaternion rkQ) -> Quaternion
    *(Real fScalar) -> Quaternion
    *(Vector3 rkVector) -> Vector3

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->operator *((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



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

  call-seq:
    get_roll(bool reprojectAxis=true) -> Radian
    get_roll -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_get_roll__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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->getRoll(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_get_roll__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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->getRoll();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Quaternion_get_roll(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_get_roll__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_get_roll__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Quaternion.get_roll", 
    "    Ogre::Radian Quaternion.get_roll(bool reprojectAxis)\n"
    "    Ogre::Radian Quaternion.get_roll()\n");
  
  return Qnil;
}



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

  call-seq:
    get_pitch(bool reprojectAxis=true) -> Radian
    get_pitch -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_get_pitch__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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->getPitch(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_get_pitch__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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->getPitch();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Quaternion_get_pitch(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_get_pitch__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_get_pitch__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Quaternion.get_pitch", 
    "    Ogre::Radian Quaternion.get_pitch(bool reprojectAxis)\n"
    "    Ogre::Radian Quaternion.get_pitch()\n");
  
  return Qnil;
}



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

  call-seq:
    get_yaw(bool reprojectAxis=true) -> Radian
    get_yaw -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_get_yaw__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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->getYaw(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_get_yaw__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);
  {
    try {
      result = ((Ogre::Quaternion const *)arg1)->getYaw();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Quaternion_get_yaw(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_get_yaw__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_get_yaw__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Quaternion.get_yaw", 
    "    Ogre::Radian Quaternion.get_yaw(bool reprojectAxis)\n"
    "    Ogre::Radian Quaternion.get_yaw()\n");
  
  return Qnil;
}



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

  call-seq:
    equals(Quaternion rhs, Radian tolerance) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::Quaternion const *)arg1)->equals((Ogre::Quaternion const &)*arg2,(Ogre::Radian const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    slerp(Real fT, Quaternion rkP, Quaternion rkQ, bool shortestPath=false) -> Quaternion
    slerp(Real fT, Quaternion rkP, Quaternion rkQ) -> Quaternion

A class method.

*/
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);
  {
    try {
      result = Ogre::Quaternion::Slerp(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = Ogre::Quaternion::Slerp(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



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

  call-seq:
    slerp_extra_spins(Real fT, Quaternion rkP, Quaternion rkQ, int iExtraSpins) -> Quaternion

A class method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_slerp_extra_spins(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);
  {
    try {
      result = Ogre::Quaternion::SlerpExtraSpins(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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.intermediate

  call-seq:
    intermediate(Quaternion rkQ0, Quaternion rkQ1, Quaternion rkQ2, 
    Quaternion rka, Quaternion rkB)

A class method.

*/
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);
  {
    try {
      Ogre::Quaternion::Intermediate((Ogre::Quaternion const &)*arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3,*arg4,*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    squad(Real fT, Quaternion rkP, Quaternion rkA, Quaternion rkB, 
    Quaternion rkQ, bool shortestPath=false) -> Quaternion
    squad(Real fT, Quaternion rkP, Quaternion rkA, Quaternion rkB, 
    Quaternion rkQ) -> Quaternion

A class method.

*/
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);
  {
    try {
      result = Ogre::Quaternion::Squad(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3,(Ogre::Quaternion const &)*arg4,(Ogre::Quaternion const &)*arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = Ogre::Quaternion::Squad(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3,(Ogre::Quaternion const &)*arg4,(Ogre::Quaternion const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
}



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

  call-seq:
    nlerp(Real fT, Quaternion rkP, Quaternion rkQ, bool shortestPath=false) -> Quaternion
    nlerp(Real fT, Quaternion rkP, Quaternion rkQ) -> Quaternion

A class method.

*/
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);
  {
    try {
      result = Ogre::Quaternion::nlerp(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = Ogre::Quaternion::nlerp(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



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

  call-seq:
    msEpsilon -> Real

Get value of attribute.

*/

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

  call-seq:
    Quaternion_msEpsilon -> Real

Get value of attribute.

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



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

  call-seq:
    ZERO -> Quaternion

Get value of attribute.

*/

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

  call-seq:
    Quaternion_ZERO -> Quaternion

Get value of attribute.

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



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

  call-seq:
    IDENTITY -> Quaternion

Get value of attribute.

*/

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

  call-seq:
    Quaternion_IDENTITY -> Quaternion

Get value of attribute.

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



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

  call-seq:
    w -> Real

Get value of attribute.

*/

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

  call-seq:
    w=(x) -> Real

Set new value for attribute.

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



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

  call-seq:
    x -> Real

Get value of attribute.

*/

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

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

Set new value for attribute.

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



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

  call-seq:
    y -> Real

Get value of attribute.

*/

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

  call-seq:
    y=(x) -> Real

Set new value for attribute.

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



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

  call-seq:
    z -> Real

Get value of attribute.

*/

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

  call-seq:
    z=(x) -> Real

Set new value for attribute.

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



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

  call-seq:
    is_na_n -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Quaternion_is_na_n(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);
  {
    try {
      result = (bool)((Ogre::Quaternion const *)arg1)->isNaN();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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


/*
  Document-class: Ogre::Vector3

  Proxy of C++ Ogre::Vector3 class


*/
swig_class SwigClassVector3;


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

  call-seq:
    x -> Real

Get value of attribute.

*/

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

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

Set new value for attribute.

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



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

  call-seq:
    y -> Real

Get value of attribute.

*/

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

  call-seq:
    y=(x) -> Real

Set new value for attribute.

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



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

  call-seq:
    z -> Real

Get value of attribute.

*/

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

  call-seq:
    z=(x) -> Real

Set new value for attribute.

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



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

  call-seq:
    Vector3.new
    Vector3.new(Real fX, Real fY, Real fZ)
    Vector3.new(Real afCoordinate)
    Vector3.new(int afCoordinate)
    Vector3.new(Real r)
    Vector3.new(Real scaler)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Vector3 *)new Ogre::Vector3();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector3 *)new Ogre::Vector3(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector3 *)new Ogre::Vector3((Ogre::Real const (*))arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector3 *)new Ogre::Vector3((int const (*))arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector3 *)new Ogre::Vector3(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Vector3 *)new Ogre::Vector3(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



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

  call-seq:
    swap(Vector3 other)

An instance method.

*/
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);
  {
    try {
      (arg1)->swap(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    ptr -> Real
    ptr -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real *)(arg1)->ptr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Real *)((Ogre::Vector3 const *)arg1)->ptr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (bool)((Ogre::Vector3 const *)arg1)->operator ==((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->operator +((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->operator -((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    *(Real fScalar) -> Vector3
    *(Vector3 rhs) -> Vector3

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->operator *(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->operator *((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



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

  call-seq:
    /(Real fScalar) -> Vector3
    /(Vector3 rhs) -> Vector3

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->operator /(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->operator /((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Vector3 const *)arg1)->operator +();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->operator -();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector3 const *)arg1)->length();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    squared_length -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_squared_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 *","squaredLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector3 const *)arg1)->squaredLength();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    distance(Vector3 rhs) -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector3 const *)arg1)->distance((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    squared_distance(Vector3 rhs) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_squared_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 *","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);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector3 const *)arg1)->squaredDistance((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    dot_product(Vector3 vec) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_dot_product(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector3 const *)arg1)->dotProduct((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    abs_dot_product(Vector3 vec) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_abs_dot_product(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector3 const *)arg1)->absDotProduct((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    normalise -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)(arg1)->normalise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    cross_product(Vector3 rkVector) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_cross_product(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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->crossProduct((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    mid_point(Vector3 vec) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_mid_point(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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->midPoint((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Vector3 const *)arg1)->operator <((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = (bool)((Ogre::Vector3 const *)arg1)->operator >((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    make_floor(Vector3 cmp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_make_floor(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);
  {
    try {
      (arg1)->makeFloor((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    make_ceil(Vector3 cmp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_make_ceil(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);
  {
    try {
      (arg1)->makeCeil((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    perpendicular -> Vector3

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->perpendicular();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    random_deviant(Radian angle, Vector3 up=) -> Vector3
    random_deviant(Radian angle) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_random_deviant__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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->randomDeviant((Ogre::Radian const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_random_deviant__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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->randomDeviant((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Vector3_random_deviant(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_random_deviant__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_random_deviant__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Vector3.random_deviant", 
    "    Ogre::Vector3 Vector3.random_deviant(Ogre::Radian const &angle, Ogre::Vector3 const &up)\n"
    "    Ogre::Vector3 Vector3.random_deviant(Ogre::Radian const &angle)\n");
  
  return Qnil;
}



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

  call-seq:
    angle_between(Vector3 dest) -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_angle_between(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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->angleBetween((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    get_rotation_to(Vector3 dest, Vector3 fallbackAxis=) -> Quaternion
    get_rotation_to(Vector3 dest) -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_get_rotation_to__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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->getRotationTo((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_get_rotation_to__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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->getRotationTo((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Vector3_get_rotation_to(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_get_rotation_to__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_get_rotation_to__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Vector3.get_rotation_to", 
    "    Ogre::Quaternion Vector3.get_rotation_to(Ogre::Vector3 const &dest, Ogre::Vector3 const &fallbackAxis)\n"
    "    Ogre::Quaternion Vector3.get_rotation_to(Ogre::Vector3 const &dest)\n");
  
  return Qnil;
}



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

  call-seq:
    is_zero_length -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_is_zero_length(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);
  {
    try {
      result = (bool)((Ogre::Vector3 const *)arg1)->isZeroLength();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    normalised_copy -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_normalised_copy(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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->normalisedCopy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    reflect(Vector3 normal) -> Vector3

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->reflect((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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.position_equals

  call-seq:
    position_equals(Vector3 rhs, Real tolerance=1e-03) -> bool
    position_equals(Vector3 rhs) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_position_equals__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);
  {
    try {
      result = (bool)((Ogre::Vector3 const *)arg1)->positionEquals((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_position_equals__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);
  {
    try {
      result = (bool)((Ogre::Vector3 const *)arg1)->positionEquals((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Vector3_position_equals(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_position_equals__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_position_equals__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Vector3.position_equals", 
    "    bool Vector3.position_equals(Ogre::Vector3 const &rhs, Ogre::Real tolerance)\n"
    "    bool Vector3.position_equals(Ogre::Vector3 const &rhs)\n");
  
  return Qnil;
}



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

  call-seq:
    position_closes(Vector3 rhs, Real tolerance=1e-03) -> bool
    position_closes(Vector3 rhs) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_position_closes__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);
  {
    try {
      result = (bool)((Ogre::Vector3 const *)arg1)->positionCloses((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_position_closes__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);
  {
    try {
      result = (bool)((Ogre::Vector3 const *)arg1)->positionCloses((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Vector3_position_closes(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_position_closes__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_position_closes__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Vector3.position_closes", 
    "    bool Vector3.position_closes(Ogre::Vector3 const &rhs, Ogre::Real tolerance)\n"
    "    bool Vector3.position_closes(Ogre::Vector3 const &rhs)\n");
  
  return Qnil;
}



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

  call-seq:
    direction_equals(Vector3 rhs, Radian tolerance) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_direction_equals(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);
  {
    try {
      result = (bool)((Ogre::Vector3 const *)arg1)->directionEquals((Ogre::Vector3 const &)*arg2,(Ogre::Radian const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    is_na_n -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_is_na_n(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);
  {
    try {
      result = (bool)((Ogre::Vector3 const *)arg1)->isNaN();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    primary_axis -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector3_primary_axis(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);
  {
    try {
      result = ((Ogre::Vector3 const *)arg1)->primaryAxis();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    UNIT_X -> Vector3

Get value of attribute.

*/

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

  call-seq:
    Vector3_UNIT_X -> Vector3

Get value of attribute.

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



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

  call-seq:
    UNIT_Y -> Vector3

Get value of attribute.

*/

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

  call-seq:
    Vector3_UNIT_Y -> Vector3

Get value of attribute.

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



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

  call-seq:
    UNIT_Z -> Vector3

Get value of attribute.

*/

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

  call-seq:
    Vector3_UNIT_Z -> Vector3

Get value of attribute.

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



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

  call-seq:
    NEGATIVE_UNIT_X -> Vector3

Get value of attribute.

*/

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

  call-seq:
    Vector3_NEGATIVE_UNIT_X -> Vector3

Get value of attribute.

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



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

  call-seq:
    NEGATIVE_UNIT_Y -> Vector3

Get value of attribute.

*/

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

  call-seq:
    Vector3_NEGATIVE_UNIT_Y -> Vector3

Get value of attribute.

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



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

  call-seq:
    NEGATIVE_UNIT_Z -> Vector3

Get value of attribute.

*/

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

  call-seq:
    Vector3_NEGATIVE_UNIT_Z -> Vector3

Get value of attribute.

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



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

  call-seq:
    UNIT_SCALE -> Vector3

Get value of attribute.

*/

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

  call-seq:
    Vector3_UNIT_SCALE -> Vector3

Get value of attribute.

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


/*
  Document-class: Ogre::Vector4

  Proxy of C++ Ogre::Vector4 class


*/
swig_class SwigClassVector4;


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

  call-seq:
    x -> Real

Get value of attribute.

*/

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

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

Set new value for attribute.

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



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

  call-seq:
    y -> Real

Get value of attribute.

*/

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

  call-seq:
    y=(x) -> Real

Set new value for attribute.

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



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

  call-seq:
    z -> Real

Get value of attribute.

*/

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

  call-seq:
    z=(x) -> Real

Set new value for attribute.

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



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

  call-seq:
    w -> Real

Get value of attribute.

*/

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

  call-seq:
    w=(x) -> Real

Set new value for attribute.

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



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

  call-seq:
    Vector4.new
    Vector4.new(Real fX, Real fY, Real fZ, Real fW)
    Vector4.new(Real afCoordinate)
    Vector4.new(int afCoordinate)
    Vector4.new(Real r)
    Vector4.new(Real scaler)
    Vector4.new(Vector3 rhs)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Vector4 *)new Ogre::Vector4();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector4 *)new Ogre::Vector4(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector4 *)new Ogre::Vector4((Ogre::Real const (*))arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector4 *)new Ogre::Vector4((int const (*))arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector4 *)new Ogre::Vector4(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Vector4 *)new Ogre::Vector4(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Vector4 *)new Ogre::Vector4((Ogre::Vector3 const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



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

  call-seq:
    swap(Vector4 other)

An instance method.

*/
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);
  {
    try {
      (arg1)->swap(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    ptr -> Real
    ptr -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real *)(arg1)->ptr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Real *)((Ogre::Vector4 const *)arg1)->ptr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (bool)((Ogre::Vector4 const *)arg1)->operator ==((Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::Vector4 const *)arg1)->operator +((Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Vector4 const *)arg1)->operator -((Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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:
    *(Real fScalar) -> Vector4
    *(Vector4 rhs) -> Vector4

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Vector4 const *)arg1)->operator *(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Vector4 const *)arg1)->operator *((Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



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

  call-seq:
    /(Real fScalar) -> Vector4
    /(Vector4 rhs) -> Vector4

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Vector4 const *)arg1)->operator /(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Vector4 const *)arg1)->operator /((Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (Ogre::Vector4 *) &((Ogre::Vector4 const *)arg1)->operator +();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      result = ((Ogre::Vector4 const *)arg1)->operator -();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    dot_product(Vector4 vec) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector4_dot_product(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Vector4 const *)arg1)->dotProduct((Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    is_na_n -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Vector4_is_na_n(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);
  {
    try {
      result = (bool)((Ogre::Vector4 const *)arg1)->isNaN();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    ZERO -> Vector4

Get value of attribute.

*/

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

  call-seq:
    Vector4_ZERO -> Vector4

Get value of attribute.

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


/*
  Document-class: Ogre::ColourValue

  Proxy of C++ Ogre::ColourValue class


*/
swig_class SwigClassColourValue;


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

  call-seq:
    ZERO -> ColourValue

Get value of attribute.

*/

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

  call-seq:
    ColourValue_ZERO -> ColourValue

Get value of attribute.

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



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

  call-seq:
    Black -> ColourValue

Get value of attribute.

*/

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

  call-seq:
    ColourValue_Black -> ColourValue

Get value of attribute.

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



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

  call-seq:
    White -> ColourValue

Get value of attribute.

*/

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

  call-seq:
    ColourValue_White -> ColourValue

Get value of attribute.

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



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

  call-seq:
    Red -> ColourValue

Get value of attribute.

*/

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

  call-seq:
    ColourValue_Red -> ColourValue

Get value of attribute.

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



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

  call-seq:
    Green -> ColourValue

Get value of attribute.

*/

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

  call-seq:
    ColourValue_Green -> ColourValue

Get value of attribute.

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



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

  call-seq:
    Blue -> ColourValue

Get value of attribute.

*/

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

  call-seq:
    ColourValue_Blue -> ColourValue

Get value of attribute.

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



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

  call-seq:
    ColourValue.new(float red=1.0, float green=1.0, float blue=1.0, float alpha=1.0)
    ColourValue.new(float red=1.0, float green=1.0, float blue=1.0)
    ColourValue.new(float red=1.0, float green=1.0)
    ColourValue.new(float red=1.0)
    ColourValue.new

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::ColourValue *)new Ogre::ColourValue(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::ColourValue *)new Ogre::ColourValue(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::ColourValue *)new Ogre::ColourValue(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::ColourValue *)new Ogre::ColourValue(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      result = (Ogre::ColourValue *)new Ogre::ColourValue();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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);
  {
    try {
      result = (bool)((Ogre::ColourValue const *)arg1)->operator ==((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    r -> float

Get value of attribute.

*/

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

  call-seq:
    r=(x) -> float

Set new value for attribute.

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



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

  call-seq:
    g -> float

Get value of attribute.

*/

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

  call-seq:
    g=(x) -> float

Set new value for attribute.

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



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

  call-seq:
    b -> float

Get value of attribute.

*/

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

  call-seq:
    b=(x) -> float

Set new value for attribute.

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



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

  call-seq:
    a -> float

Get value of attribute.

*/

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

  call-seq:
    a=(x) -> float

Set new value for attribute.

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



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

  call-seq:
    get_as_rgba -> RGBA

An instance method.

*/
SWIGINTERN VALUE
_wrap_ColourValue_get_as_rgba(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);
  {
    try {
      result = (Ogre::RGBA)((Ogre::ColourValue const *)arg1)->getAsRGBA();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    get_as_argb -> ARGB

An instance method.

*/
SWIGINTERN VALUE
_wrap_ColourValue_get_as_argb(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);
  {
    try {
      result = (Ogre::ARGB)((Ogre::ColourValue const *)arg1)->getAsARGB();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    get_as_bgra -> BGRA

An instance method.

*/
SWIGINTERN VALUE
_wrap_ColourValue_get_as_bgra(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);
  {
    try {
      result = (Ogre::BGRA)((Ogre::ColourValue const *)arg1)->getAsBGRA();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    get_as_abgr -> ABGR

An instance method.

*/
SWIGINTERN VALUE
_wrap_ColourValue_get_as_abgr(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);
  {
    try {
      result = (Ogre::ABGR)((Ogre::ColourValue const *)arg1)->getAsABGR();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    set_as_rgba(RGBA val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ColourValue_set_as_rgba(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);
  {
    try {
      (arg1)->setAsRGBA(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    set_as_argb(ARGB val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ColourValue_set_as_argb(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);
  {
    try {
      (arg1)->setAsARGB(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    set_as_bgra(BGRA val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ColourValue_set_as_bgra(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);
  {
    try {
      (arg1)->setAsBGRA(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    set_as_abgr(ABGR val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ColourValue_set_as_abgr(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);
  {
    try {
      (arg1)->setAsABGR(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    saturate

An instance method.

*/
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);
  {
    try {
      (arg1)->saturate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    saturate_copy -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_ColourValue_saturate_copy(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);
  {
    try {
      result = ((Ogre::ColourValue const *)arg1)->saturateCopy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    ptr -> float
    ptr -> float

An instance method.

*/
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);
  {
    try {
      result = (float *)(arg1)->ptr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (float *)((Ogre::ColourValue const *)arg1)->ptr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = ((Ogre::ColourValue const *)arg1)->operator +((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::ColourValue const *)arg1)->operator -((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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:
    *(float fScalar) -> ColourValue
    *(ColourValue rhs) -> ColourValue

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::ColourValue const *)arg1)->operator *(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::ColourValue const *)arg1)->operator *((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



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

  call-seq:
    /(ColourValue rhs) -> ColourValue
    /(float fScalar) -> ColourValue

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::ColourValue const *)arg1)->operator /((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::ColourValue const *)arg1)->operator /(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



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

  call-seq:
    set_hsb(Real hue, Real saturation, Real brightness)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ColourValue_set_hsb(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);
  {
    try {
      (arg1)->setHSB(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    get_hsb(Real hue, Real saturation, Real brightness)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ColourValue_get_hsb(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);
  {
    try {
      ((Ogre::ColourValue const *)arg1)->getHSB(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


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


/*
  Document-class: Ogre::StringUtil

  Proxy of C++ Ogre::StringUtil class


*/
swig_class SwigClassStringUtil;


/*
  Document-method: Ogre::StringUtil.trim

  call-seq:
    trim(String str, bool left=true, bool right=true)
    trim(String str, bool left=true)
    trim(String str)

A class method.

*/
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);
  {
    try {
      Ogre::StringUtil::trim(*arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      Ogre::StringUtil::trim(*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      Ogre::StringUtil::trim(*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::StringUtil.split

  call-seq:
    split(String str, String delims="\t\n ", unsigned int maxSplits=0, 
    bool preserveDelims=false) -> Ogre::vector<(Ogre::String,Ogre::STLAllocator<(Ogre::String,Ogre::GeneralAllocPolicy)>)>::type
    split(String str, String delims="\t\n ", unsigned int maxSplits=0) -> Ogre::vector<(Ogre::String,Ogre::STLAllocator<(Ogre::String,Ogre::GeneralAllocPolicy)>)>::type
    split(String str, String delims="\t\n ") -> Ogre::vector<(Ogre::String,Ogre::STLAllocator<(Ogre::String,Ogre::GeneralAllocPolicy)>)>::type
    split(String str) -> Ogre::vector<(Ogre::String,Ogre::STLAllocator<(Ogre::String,Ogre::GeneralAllocPolicy)>)>::type

A class method.

*/
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);
  {
    try {
      result = Ogre::StringUtil::split((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = Ogre::StringUtil::split((std::string const &)*arg1,(std::string const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
  }
  {
    try {
      result = Ogre::StringUtil::split((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
  }
  {
    try {
      result = Ogre::StringUtil::split((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringUtil.tokenise

  call-seq:
    tokenise(String str, String delims="\t\n ", String doubleDelims="\"", 
    unsigned int maxSplits=0) -> Ogre::vector<(Ogre::String,Ogre::STLAllocator<(Ogre::String,Ogre::GeneralAllocPolicy)>)>::type
    tokenise(String str, String delims="\t\n ", String doubleDelims="\"") -> Ogre::vector<(Ogre::String,Ogre::STLAllocator<(Ogre::String,Ogre::GeneralAllocPolicy)>)>::type
    tokenise(String str, String delims="\t\n ") -> Ogre::vector<(Ogre::String,Ogre::STLAllocator<(Ogre::String,Ogre::GeneralAllocPolicy)>)>::type
    tokenise(String str) -> Ogre::vector<(Ogre::String,Ogre::STLAllocator<(Ogre::String,Ogre::GeneralAllocPolicy)>)>::type

A class method.

*/
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);
  {
    try {
      result = Ogre::StringUtil::tokenise((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
  }
  {
    try {
      result = Ogre::StringUtil::tokenise((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
  }
  {
    try {
      result = Ogre::StringUtil::tokenise((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
  }
  {
    try {
      result = Ogre::StringUtil::tokenise((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringUtil.to_lower_case

  call-seq:
    to_lower_case(String str)

A class method.

*/
SWIGINTERN VALUE
_wrap_StringUtil_to_lower_case(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);
  {
    try {
      Ogre::StringUtil::toLowerCase(*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringUtil.to_upper_case

  call-seq:
    to_upper_case(String str)

A class method.

*/
SWIGINTERN VALUE
_wrap_StringUtil_to_upper_case(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);
  {
    try {
      Ogre::StringUtil::toUpperCase(*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringUtil.starts_with

  call-seq:
    starts_with(String str, String pattern, bool lowerCase=true) -> bool
    starts_with(String str, String pattern) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_StringUtil_starts_with__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);
  {
    try {
      result = (bool)Ogre::StringUtil::startsWith((std::string const &)*arg1,(std::string const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_starts_with__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;
  }
  {
    try {
      result = (bool)Ogre::StringUtil::startsWith((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_starts_with(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_starts_with__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_starts_with__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "StringUtil.starts_with", 
    "    bool StringUtil.starts_with(Ogre::String const &str, Ogre::String const &pattern, bool lowerCase)\n"
    "    bool StringUtil.starts_with(Ogre::String const &str, Ogre::String const &pattern)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringUtil.ends_with

  call-seq:
    ends_with(String str, String pattern, bool lowerCase=true) -> bool
    ends_with(String str, String pattern) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_StringUtil_ends_with__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);
  {
    try {
      result = (bool)Ogre::StringUtil::endsWith((std::string const &)*arg1,(std::string const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_ends_with__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;
  }
  {
    try {
      result = (bool)Ogre::StringUtil::endsWith((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_ends_with(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_ends_with__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_ends_with__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "StringUtil.ends_with", 
    "    bool StringUtil.ends_with(Ogre::String const &str, Ogre::String const &pattern, bool lowerCase)\n"
    "    bool StringUtil.ends_with(Ogre::String const &str, Ogre::String const &pattern)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringUtil.standardise_path

  call-seq:
    standardise_path(String init) -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_StringUtil_standardise_path(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;
  }
  {
    try {
      result = Ogre::StringUtil::standardisePath((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}



/*
  Document-method: Ogre::StringUtil.normalize_file_path

  call-seq:
    normalize_file_path(String init, bool makeLowerCase=true) -> String
    normalize_file_path(String init) -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_StringUtil_normalize_file_path__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);
  {
    try {
      result = Ogre::StringUtil::normalizeFilePath((std::string const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_normalize_file_path__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;
  }
  {
    try {
      result = Ogre::StringUtil::normalizeFilePath((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringUtil_normalize_file_path(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_normalize_file_path__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_normalize_file_path__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringUtil.normalize_file_path", 
    "    Ogre::String StringUtil.normalize_file_path(Ogre::String const &init, bool makeLowerCase)\n"
    "    Ogre::String StringUtil.normalize_file_path(Ogre::String const &init)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringUtil.split_filename

  call-seq:
    split_filename(String qualifiedName, String outBasename, String outPath)

A class method.

*/
SWIGINTERN VALUE
_wrap_StringUtil_split_filename(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);
  {
    try {
      Ogre::StringUtil::splitFilename((std::string const &)*arg1,*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}



/*
  Document-method: Ogre::StringUtil.split_full_filename

  call-seq:
    split_full_filename(String qualifiedName, String outBasename, String outExtention, 
    String outPath)

A class method.

*/
SWIGINTERN VALUE
_wrap_StringUtil_split_full_filename(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);
  {
    try {
      Ogre::StringUtil::splitFullFilename((std::string const &)*arg1,*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}



/*
  Document-method: Ogre::StringUtil.split_base_filename

  call-seq:
    split_base_filename(String fullName, String outBasename, String outExtention)

A class method.

*/
SWIGINTERN VALUE
_wrap_StringUtil_split_base_filename(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);
  {
    try {
      Ogre::StringUtil::splitBaseFilename((std::string const &)*arg1,*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}



/*
  Document-method: Ogre::StringUtil.match

  call-seq:
    match(String str, String pattern, bool caseSensitive=true) -> bool
    match(String str, String pattern) -> bool

A class method.

*/
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);
  {
    try {
      result = (bool)Ogre::StringUtil::match((std::string const &)*arg1,(std::string const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
  }
  {
    try {
      result = (bool)Ogre::StringUtil::match((std::string const &)*arg1,(std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringUtil.replace_all

  call-seq:
    replace_all(String source, String replaceWhat, String replaceWithWhat) -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_StringUtil_replace_all(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;
  }
  {
    try {
      result = Ogre::StringUtil::replaceAll((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringUtil.BLANK

  call-seq:
    BLANK -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::StringUtil.StringUtil_BLANK

  call-seq:
    StringUtil_BLANK -> String

Get value of attribute.

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


/*
  Document-method: Ogre::StringUtil.new

  call-seq:
    StringUtil.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::StringUtil *)new Ogre::StringUtil();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


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


/*
  Document-class: Ogre::Exception

  Proxy of C++ Ogre::Exception class


*/
swig_class SwigClassException;


/*
  Document-method: Ogre::ExceptionCodes.ERR_CANNOT_WRITE_TO_FILE

  call-seq:
    ERR_CANNOT_WRITE_TO_FILE -> int

A class method.

*/

/*
  Document-method: Ogre::ExceptionCodes.ERR_INVALID_STATE

  call-seq:
    ERR_INVALID_STATE -> int

A class method.

*/

/*
  Document-method: Ogre::ExceptionCodes.ERR_INVALIDPARAMS

  call-seq:
    ERR_INVALIDPARAMS -> int

A class method.

*/

/*
  Document-method: Ogre::ExceptionCodes.ERR_RENDERINGAPI_ERROR

  call-seq:
    ERR_RENDERINGAPI_ERROR -> int

A class method.

*/

/*
  Document-method: Ogre::ExceptionCodes.ERR_DUPLICATE_ITEM

  call-seq:
    ERR_DUPLICATE_ITEM -> int

A class method.

*/

/*
  Document-method: Ogre::ExceptionCodes.ERR_ITEM_NOT_FOUND

  call-seq:
    ERR_ITEM_NOT_FOUND -> int

A class method.

*/

/*
  Document-method: Ogre::ExceptionCodes.ERR_FILE_NOT_FOUND

  call-seq:
    ERR_FILE_NOT_FOUND -> int

A class method.

*/

/*
  Document-method: Ogre::ExceptionCodes.ERR_INTERNAL_ERROR

  call-seq:
    ERR_INTERNAL_ERROR -> int

A class method.

*/

/*
  Document-method: Ogre::ExceptionCodes.ERR_RT_ASSERTION_FAILED

  call-seq:
    ERR_RT_ASSERTION_FAILED -> int

A class method.

*/

/*
  Document-method: Ogre::ExceptionCodes.ERR_NOT_IMPLEMENTED

  call-seq:
    ERR_NOT_IMPLEMENTED -> int

A class method.

*/

/*
  Document-method: Ogre::Exception.new

  call-seq:
    Exception.new(int number, String description, String source)
    Exception.new(int number, String description, String source, char type, 
    char file, long line)
    Exception.new(Exception rhs)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Exception *)new Ogre::Exception(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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);
  {
    try {
      result = (Ogre::Exception *)new Ogre::Exception((Ogre::Exception const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::Exception.get_full_description

  call-seq:
    get_full_description -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Exception_get_full_description(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Exception const *)arg1)->getFullDescription();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Exception.get_number

  call-seq:
    get_number -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Exception_get_number(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);
  {
    try {
      result = (int)((Ogre::Exception const *)arg1)->getNumber();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Exception.get_source

  call-seq:
    get_source -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Exception_get_source(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Exception const *)arg1)->getSource();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Exception.get_file

  call-seq:
    get_file -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Exception_get_file(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Exception const *)arg1)->getFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Exception.get_line

  call-seq:
    get_line -> long

An instance method.

*/
SWIGINTERN VALUE
_wrap_Exception_get_line(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);
  {
    try {
      result = (long)((Ogre::Exception const *)arg1)->getLine();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Exception.get_description

  call-seq:
    get_description -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Exception_get_description(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Exception const *)arg1)->getDescription();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Exception.what

  call-seq:
    what -> char

An instance method.

*/
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);
  {
    try {
      result = (char *)((Ogre::Exception const *)arg1)->what();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::UnimplementedException < Ogre::Ogre::Exception

  Proxy of C++ Ogre::UnimplementedException class


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


/*
  Document-method: Ogre::UnimplementedException.new

  call-seq:
    UnimplementedException.new(int inNumber, String inDescription, String inSource, 
    char inFile, long inLine)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::UnimplementedException *)new Ogre::UnimplementedException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::FileNotFoundException < Ogre::Ogre::Exception

  Proxy of C++ Ogre::FileNotFoundException class


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


/*
  Document-method: Ogre::FileNotFoundException.new

  call-seq:
    FileNotFoundException.new(int inNumber, String inDescription, String inSource, 
    char inFile, long inLine)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::FileNotFoundException *)new Ogre::FileNotFoundException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::IOException < Ogre::Ogre::Exception

  Proxy of C++ Ogre::IOException class


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


/*
  Document-method: Ogre::IOException.new

  call-seq:
    IOException.new(int inNumber, String inDescription, String inSource, 
    char inFile, long inLine)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::IOException *)new Ogre::IOException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::InvalidStateException < Ogre::Ogre::Exception

  Proxy of C++ Ogre::InvalidStateException class


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


/*
  Document-method: Ogre::InvalidStateException.new

  call-seq:
    InvalidStateException.new(int inNumber, String inDescription, String inSource, 
    char inFile, long inLine)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::InvalidStateException *)new Ogre::InvalidStateException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::InvalidParametersException < Ogre::Ogre::Exception

  Proxy of C++ Ogre::InvalidParametersException class


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


/*
  Document-method: Ogre::InvalidParametersException.new

  call-seq:
    InvalidParametersException.new(int inNumber, String inDescription, String inSource, 
    char inFile, long inLine)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::InvalidParametersException *)new Ogre::InvalidParametersException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::ItemIdentityException < Ogre::Ogre::Exception

  Proxy of C++ Ogre::ItemIdentityException class


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


/*
  Document-method: Ogre::ItemIdentityException.new

  call-seq:
    ItemIdentityException.new(int inNumber, String inDescription, String inSource, 
    char inFile, long inLine)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::ItemIdentityException *)new Ogre::ItemIdentityException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::InternalErrorException < Ogre::Ogre::Exception

  Proxy of C++ Ogre::InternalErrorException class


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


/*
  Document-method: Ogre::InternalErrorException.new

  call-seq:
    InternalErrorException.new(int inNumber, String inDescription, String inSource, 
    char inFile, long inLine)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::InternalErrorException *)new Ogre::InternalErrorException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::RenderingAPIException < Ogre::Ogre::Exception

  Proxy of C++ Ogre::RenderingAPIException class


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


/*
  Document-method: Ogre::RenderingAPIException.new

  call-seq:
    RenderingAPIException.new(int inNumber, String inDescription, String inSource, 
    char inFile, long inLine)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::RenderingAPIException *)new Ogre::RenderingAPIException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::RuntimeAssertionException < Ogre::Ogre::Exception

  Proxy of C++ Ogre::RuntimeAssertionException class


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


/*
  Document-method: Ogre::RuntimeAssertionException.new

  call-seq:
    RuntimeAssertionException.new(int inNumber, String inDescription, String inSource, 
    char inFile, long inLine)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::RuntimeAssertionException *)new Ogre::RuntimeAssertionException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::ExceptionFactory

  Proxy of C++ Ogre::ExceptionFactory class


*/
swig_class SwigClassExceptionFactory;


/*
  Document-method: Ogre::ExceptionFactory.create

  call-seq:
    create(Ogre::ExceptionCodeType<(Ogre::Exception::ERR_NOT_IMPLEMENTED)> code, 
    String desc, String src, char file, 
    long line) -> UnimplementedException
    create(Ogre::ExceptionCodeType<(Ogre::Exception::ERR_FILE_NOT_FOUND)> code, 
    String desc, String src, char file, 
    long line) -> FileNotFoundException
    create(Ogre::ExceptionCodeType<(Ogre::Exception::ERR_CANNOT_WRITE_TO_FILE)> code, 
    String desc, String src, 
    char file, long line) -> IOException
    create(Ogre::ExceptionCodeType<(Ogre::Exception::ERR_INVALID_STATE)> code, 
    String desc, String src, char file, 
    long line) -> InvalidStateException
    create(Ogre::ExceptionCodeType<(Ogre::Exception::ERR_INVALIDPARAMS)> code, 
    String desc, String src, char file, 
    long line) -> InvalidParametersException
    create(Ogre::ExceptionCodeType<(Ogre::Exception::ERR_ITEM_NOT_FOUND)> code, 
    String desc, String src, char file, 
    long line) -> ItemIdentityException
    create(Ogre::ExceptionCodeType<(Ogre::Exception::ERR_DUPLICATE_ITEM)> code, 
    String desc, String src, char file, 
    long line) -> ItemIdentityException
    create(Ogre::ExceptionCodeType<(Ogre::Exception::ERR_INTERNAL_ERROR)> code, 
    String desc, String src, char file, 
    long line) -> InternalErrorException
    create(Ogre::ExceptionCodeType<(Ogre::Exception::ERR_RENDERINGAPI_ERROR)> code, 
    String desc, String src, 
    char file, long line) -> RenderingAPIException
    create(Ogre::ExceptionCodeType<(Ogre::Exception::ERR_RT_ASSERTION_FAILED)> code, 
    String desc, String src, 
    char file, long line) -> RuntimeAssertionException

A class method.

*/
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);
  {
    try {
      result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
}


/*
  Document-class: Ogre::Any

  Proxy of C++ Ogre::Any class


*/
swig_class SwigClassAny;


/*
  Document-method: Ogre::Any.new

  call-seq:
    Any.new
    Any.new(Any other)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Any *)new Ogre::Any();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Any *)new Ogre::Any((Ogre::Any const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::Any.swap

  call-seq:
    swap(Any rhs) -> Any

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Any *) &(arg1)->swap(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Any.is_empty

  call-seq:
    is_empty -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Any_is_empty(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);
  {
    try {
      result = (bool)((Ogre::Any const *)arg1)->isEmpty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Any.get_type

  call-seq:
    get_type -> std::type_info

An instance method.

*/
SWIGINTERN VALUE
_wrap_Any_get_type(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);
  {
    try {
      result = (std::type_info *) &((Ogre::Any const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__type_info, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Any.destroy

  call-seq:
    destroy

An instance method.

*/
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);
  {
    try {
      (arg1)->destroy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Any.to_value

  call-seq:
    to_value -> AnyVALUE

An instance method.

*/
SWIGINTERN VALUE
_wrap_Any_to_value(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);
  {
    try {
      result = (Ogre::AnyVALUE *)Ogre_Any_toVALUE(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnyVALUE, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::AnyNumeric < Ogre::Ogre::Any

  Proxy of C++ Ogre::AnyNumeric class


*/
swig_class SwigClassAnyNumeric;


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

  call-seq:
    AnyNumeric.new
    AnyNumeric.new(AnyNumeric other)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::AnyNumeric *)new Ogre::AnyNumeric();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::AnyNumeric *)new Ogre::AnyNumeric((Ogre::AnyNumeric const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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);
  {
    try {
      result = ((Ogre::AnyNumeric const *)arg1)->operator +((Ogre::AnyNumeric const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::AnyNumeric const *)arg1)->operator -((Ogre::AnyNumeric const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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:
    *(AnyNumeric rhs) -> AnyNumeric
    *(Real factor) -> AnyNumeric

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::AnyNumeric const *)arg1)->operator *((Ogre::AnyNumeric const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::AnyNumeric const *)arg1)->operator *(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



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

  call-seq:
    /(AnyNumeric rhs) -> AnyNumeric

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::AnyNumeric const *)arg1)->operator /((Ogre::AnyNumeric const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}


/*
  Document-class: Ogre::AnyVALUE < Ogre::Ogre::Any

  Proxy of C++ Ogre::AnyVALUE class


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


/*
  Document-method: Ogre::AnyVALUE.new

  call-seq:
    AnyVALUE.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::AnyVALUE *)new Ogre::AnyVALUE();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnyVALUE.set_value

  call-seq:
    set_value(VALUE value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnyVALUE_set_value(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];
  {
    try {
      (arg1)->setVALUE(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnyVALUE.get_value

  call-seq:
    get_value -> VALUE

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnyVALUE_get_value(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);
  {
    try {
      result = (VALUE)(arg1)->getVALUE();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = result;
  return vresult;
fail:
  return Qnil;
}


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


/*
  Document-class: Ogre::AnimableValue

  Proxy of C++ Ogre::AnimableValue class


*/
swig_class SwigClassAnimableValue;


/*
  Document-method: Ogre::ValueType.INT

  call-seq:
    INT -> int

A class method.

*/

/*
  Document-method: Ogre::ValueType.REAL

  call-seq:
    REAL -> int

A class method.

*/

/*
  Document-method: Ogre::ValueType.VECTOR2

  call-seq:
    VECTOR2 -> int

A class method.

*/

/*
  Document-method: Ogre::ValueType.VECTOR3

  call-seq:
    VECTOR3 -> int

A class method.

*/

/*
  Document-method: Ogre::ValueType.VECTOR4

  call-seq:
    VECTOR4 -> int

A class method.

*/

/*
  Document-method: Ogre::ValueType.QUATERNION

  call-seq:
    QUATERNION -> int

A class method.

*/

/*
  Document-method: Ogre::ValueType.COLOUR

  call-seq:
    COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::ValueType.RADIAN

  call-seq:
    RADIAN -> int

A class method.

*/

/*
  Document-method: Ogre::ValueType.DEGREE

  call-seq:
    DEGREE -> int

A class method.

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


/*
  Document-method: Ogre::AnimableValue.get_type

  call-seq:
    get_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimableValue_get_type(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);
  {
    try {
      result = (Ogre::AnimableValue::ValueType)((Ogre::AnimableValue const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimableValue.set_current_state_as_base_value

  call-seq:
    set_current_state_as_base_value

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimableValue_set_current_state_as_base_value(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);
  {
    try {
      (arg1)->setCurrentStateAsBaseValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimableValue.set_value

  call-seq:
    set_value(int ?)
    set_value(Real ?)
    set_value(Vector2 ?)
    set_value(Vector3 ?)
    set_value(Vector4 ?)
    set_value(Quaternion ?)
    set_value(ColourValue ?)
    set_value(Radian ?)
    set_value(Degree ?)
    set_value(Any val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimableValue_set_value__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);
  {
    try {
      (arg1)->setValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_set_value__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);
  {
    try {
      (arg1)->setValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_set_value__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);
  {
    try {
      (arg1)->setValue((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_set_value__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);
  {
    try {
      (arg1)->setValue((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_set_value__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);
  {
    try {
      (arg1)->setValue((Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_set_value__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);
  {
    try {
      (arg1)->setValue((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_set_value__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);
  {
    try {
      (arg1)->setValue((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_set_value__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);
  {
    try {
      (arg1)->setValue((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_set_value__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);
  {
    try {
      (arg1)->setValue((Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_set_value__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);
  {
    try {
      (arg1)->setValue((Ogre::Any const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimableValue_set_value(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_set_value__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_set_value__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_set_value__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_set_value__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_set_value__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_set_value__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_set_value__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_set_value__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_set_value__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_set_value__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "AnimableValue.set_value", 
    "    void AnimableValue.set_value(int)\n"
    "    void AnimableValue.set_value(Ogre::Real)\n"
    "    void AnimableValue.set_value(Ogre::Vector2 const &)\n"
    "    void AnimableValue.set_value(Ogre::Vector3 const &)\n"
    "    void AnimableValue.set_value(Ogre::Vector4 const &)\n"
    "    void AnimableValue.set_value(Ogre::Quaternion const &)\n"
    "    void AnimableValue.set_value(Ogre::ColourValue const &)\n"
    "    void AnimableValue.set_value(Ogre::Radian const &)\n"
    "    void AnimableValue.set_value(Ogre::Degree const &)\n"
    "    void AnimableValue.set_value(Ogre::Any const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AnimableValue.reset_to_base_value

  call-seq:
    reset_to_base_value

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimableValue_reset_to_base_value(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);
  {
    try {
      (arg1)->resetToBaseValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimableValue.apply_delta_value

  call-seq:
    apply_delta_value(int ?)
    apply_delta_value(Real ?)
    apply_delta_value(Vector2 ?)
    apply_delta_value(Vector3 ?)
    apply_delta_value(Vector4 ?)
    apply_delta_value(Quaternion ?)
    apply_delta_value(ColourValue ?)
    apply_delta_value(Degree ?)
    apply_delta_value(Radian ?)
    apply_delta_value(Any val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimableValue_apply_delta_value__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);
  {
    try {
      (arg1)->applyDeltaValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_apply_delta_value__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);
  {
    try {
      (arg1)->applyDeltaValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_apply_delta_value__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);
  {
    try {
      (arg1)->applyDeltaValue((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_apply_delta_value__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);
  {
    try {
      (arg1)->applyDeltaValue((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_apply_delta_value__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);
  {
    try {
      (arg1)->applyDeltaValue((Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_apply_delta_value__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);
  {
    try {
      (arg1)->applyDeltaValue((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_apply_delta_value__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);
  {
    try {
      (arg1)->applyDeltaValue((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_apply_delta_value__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);
  {
    try {
      (arg1)->applyDeltaValue((Ogre::Degree const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_apply_delta_value__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);
  {
    try {
      (arg1)->applyDeltaValue((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_apply_delta_value__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);
  {
    try {
      (arg1)->applyDeltaValue((Ogre::Any const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimableValue_apply_delta_value(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_apply_delta_value__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_apply_delta_value__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_apply_delta_value__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_apply_delta_value__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_apply_delta_value__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_apply_delta_value__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_apply_delta_value__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_apply_delta_value__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_apply_delta_value__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_apply_delta_value__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "AnimableValue.apply_delta_value", 
    "    void AnimableValue.apply_delta_value(int)\n"
    "    void AnimableValue.apply_delta_value(Ogre::Real)\n"
    "    void AnimableValue.apply_delta_value(Ogre::Vector2 const &)\n"
    "    void AnimableValue.apply_delta_value(Ogre::Vector3 const &)\n"
    "    void AnimableValue.apply_delta_value(Ogre::Vector4 const &)\n"
    "    void AnimableValue.apply_delta_value(Ogre::Quaternion const &)\n"
    "    void AnimableValue.apply_delta_value(Ogre::ColourValue const &)\n"
    "    void AnimableValue.apply_delta_value(Ogre::Degree const &)\n"
    "    void AnimableValue.apply_delta_value(Ogre::Radian const &)\n"
    "    void AnimableValue.apply_delta_value(Ogre::Any const &val)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::AnimableObject

  Proxy of C++ Ogre::AnimableObject class


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


/*
  Document-method: Ogre::AnimableObject.new

  call-seq:
    AnimableObject.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::AnimableObject *)new Ogre::AnimableObject();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::AnimableObject.get_animable_value_names

  call-seq:
    get_animable_value_names -> StringVector

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimableObject_get_animable_value_names(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);
  {
    try {
      result = (Ogre::StringVector *) &((Ogre::AnimableObject const *)arg1)->getAnimableValueNames();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimableObject.create_animable_value

  call-seq:
    create_animable_value(String valueName) -> AnimableValuePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimableObject_create_animable_value(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;
  }
  {
    try {
      result = (arg1)->createAnimableValue((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-class: Ogre::Matrix3

  Proxy of C++ Ogre::Matrix3 class


*/
swig_class SwigClassMatrix3;


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

  call-seq:
    Matrix3.new
    Matrix3.new(Real arr)
    Matrix3.new(Matrix3 rkMatrix)
    Matrix3.new(Real fEntry00, Real fEntry01, Real fEntry02, Real fEntry10, 
    Real fEntry11, Real fEntry12, Real fEntry20, 
    Real fEntry21, Real fEntry22)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Matrix3 *)new Ogre::Matrix3();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Matrix3 *)new Ogre::Matrix3((Ogre::Real const (*)[3])arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Matrix3 *)new Ogre::Matrix3((Ogre::Matrix3 const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Matrix3 *)new Ogre::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



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

  call-seq:
    swap(Matrix3 other)

An instance method.

*/
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);
  {
    try {
      (arg1)->swap(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    get_column(size_t iCol) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_get_column(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);
  {
    try {
      result = ((Ogre::Matrix3 const *)arg1)->GetColumn(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    set_column(size_t iCol, Vector3 vec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_set_column(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);
  {
    try {
      (arg1)->SetColumn(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    from_axes(Vector3 xAxis, Vector3 yAxis, Vector3 zAxis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_from_axes(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);
  {
    try {
      (arg1)->FromAxes((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (bool)((Ogre::Matrix3 const *)arg1)->operator ==((Ogre::Matrix3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::Matrix3 const *)arg1)->operator +((Ogre::Matrix3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Matrix3 const *)arg1)->operator -((Ogre::Matrix3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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 rkMatrix) -> Matrix3
    *(Vector3 rkVector) -> Vector3
    *(Real fScalar) -> Matrix3

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Matrix3 const *)arg1)->operator *((Ogre::Matrix3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Matrix3 const *)arg1)->operator -();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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 rkMatrix) -> Matrix3
    *(Vector3 rkVector) -> Vector3
    *(Real fScalar) -> Matrix3

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Matrix3 const *)arg1)->operator *((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = ((Ogre::Matrix3 const *)arg1)->operator *(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



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

  call-seq:
    transpose -> Matrix3

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Matrix3 const *)arg1)->Transpose();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    inverse(Matrix3 rkInverse, Real fTolerance=1e-06) -> bool
    inverse(Matrix3 rkInverse) -> bool
    inverse(Real fTolerance=1e-06) -> Matrix3
    inverse -> Matrix3

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::Matrix3 const *)arg1)->Inverse(*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (bool)((Ogre::Matrix3 const *)arg1)->Inverse(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = ((Ogre::Matrix3 const *)arg1)->Inverse(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Matrix3 const *)arg1)->Inverse();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



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

  call-seq:
    determinant -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)((Ogre::Matrix3 const *)arg1)->Determinant();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    singular_value_decomposition(Matrix3 rkL, Vector3 rkS, Matrix3 rkR)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_singular_value_decomposition(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);
  {
    try {
      ((Ogre::Matrix3 const *)arg1)->SingularValueDecomposition(*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    singular_value_composition(Matrix3 rkL, Vector3 rkS, Matrix3 rkR)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_singular_value_composition(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);
  {
    try {
      (arg1)->SingularValueComposition((Ogre::Matrix3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Matrix3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    orthonormalize

An instance method.

*/
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);
  {
    try {
      (arg1)->Orthonormalize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    qdudecomposition(Matrix3 rkQ, Vector3 rkD, Vector3 rkU)

An instance method.

*/
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);
  {
    try {
      ((Ogre::Matrix3 const *)arg1)->QDUDecomposition(*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    spectral_norm -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_spectral_norm(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Matrix3 const *)arg1)->SpectralNorm();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    to_angle_axis(Vector3 rkAxis, Radian rfAngle)
    to_angle_axis(Vector3 rkAxis, Degree rfAngle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_to_angle_axis__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);
  {
    try {
      ((Ogre::Matrix3 const *)arg1)->ToAngleAxis(*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_to_angle_axis__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);
  {
    try {
      ((Ogre::Matrix3 const *)arg1)->ToAngleAxis(*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Matrix3_to_angle_axis(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_to_angle_axis__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_to_angle_axis__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Matrix3.to_angle_axis", 
    "    void Matrix3.to_angle_axis(Ogre::Vector3 &rkAxis, Ogre::Radian &rfAngle)\n"
    "    void Matrix3.to_angle_axis(Ogre::Vector3 &rkAxis, Ogre::Degree &rfAngle)\n");
  
  return Qnil;
}



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

  call-seq:
    from_angle_axis(Vector3 rkAxis, Radian fRadians)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_from_angle_axis(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);
  {
    try {
      (arg1)->FromAngleAxis((Ogre::Vector3 const &)*arg2,(Ogre::Radian const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    to_euler_angles_xyz(Radian rfYAngle, Radian rfPAngle, Radian rfRAngle) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_to_euler_angles_xyz(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);
  {
    try {
      result = (bool)((Ogre::Matrix3 const *)arg1)->ToEulerAnglesXYZ(*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    to_euler_angles_xzy(Radian rfYAngle, Radian rfPAngle, Radian rfRAngle) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_to_euler_angles_xzy(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);
  {
    try {
      result = (bool)((Ogre::Matrix3 const *)arg1)->ToEulerAnglesXZY(*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    to_euler_angles_yxz(Radian rfYAngle, Radian rfPAngle, Radian rfRAngle) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_to_euler_angles_yxz(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);
  {
    try {
      result = (bool)((Ogre::Matrix3 const *)arg1)->ToEulerAnglesYXZ(*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    to_euler_angles_yzx(Radian rfYAngle, Radian rfPAngle, Radian rfRAngle) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_to_euler_angles_yzx(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);
  {
    try {
      result = (bool)((Ogre::Matrix3 const *)arg1)->ToEulerAnglesYZX(*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    to_euler_angles_zxy(Radian rfYAngle, Radian rfPAngle, Radian rfRAngle) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_to_euler_angles_zxy(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);
  {
    try {
      result = (bool)((Ogre::Matrix3 const *)arg1)->ToEulerAnglesZXY(*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    to_euler_angles_zyx(Radian rfYAngle, Radian rfPAngle, Radian rfRAngle) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_to_euler_angles_zyx(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);
  {
    try {
      result = (bool)((Ogre::Matrix3 const *)arg1)->ToEulerAnglesZYX(*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    from_euler_angles_xyz(Radian fYAngle, Radian fPAngle, Radian fRAngle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_from_euler_angles_xyz(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);
  {
    try {
      (arg1)->FromEulerAnglesXYZ((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,(Ogre::Radian const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    from_euler_angles_xzy(Radian fYAngle, Radian fPAngle, Radian fRAngle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_from_euler_angles_xzy(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);
  {
    try {
      (arg1)->FromEulerAnglesXZY((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,(Ogre::Radian const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    from_euler_angles_yxz(Radian fYAngle, Radian fPAngle, Radian fRAngle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_from_euler_angles_yxz(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);
  {
    try {
      (arg1)->FromEulerAnglesYXZ((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,(Ogre::Radian const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    from_euler_angles_yzx(Radian fYAngle, Radian fPAngle, Radian fRAngle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_from_euler_angles_yzx(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);
  {
    try {
      (arg1)->FromEulerAnglesYZX((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,(Ogre::Radian const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    from_euler_angles_zxy(Radian fYAngle, Radian fPAngle, Radian fRAngle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_from_euler_angles_zxy(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);
  {
    try {
      (arg1)->FromEulerAnglesZXY((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,(Ogre::Radian const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    from_euler_angles_zyx(Radian fYAngle, Radian fPAngle, Radian fRAngle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_from_euler_angles_zyx(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);
  {
    try {
      (arg1)->FromEulerAnglesZYX((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,(Ogre::Radian const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    eigen_solve_symmetric(Real afEigenvalue, Vector3 akEigenvector)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_eigen_solve_symmetric(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);
  {
    try {
      ((Ogre::Matrix3 const *)arg1)->EigenSolveSymmetric(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    tensor_product(Vector3 rkU, Vector3 rkV, Matrix3 rkProduct)

A class method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_tensor_product(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);
  {
    try {
      Ogre::Matrix3::TensorProduct((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    has_scale -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix3_has_scale(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);
  {
    try {
      result = (bool)((Ogre::Matrix3 const *)arg1)->hasScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



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

  call-seq:
    EPSILON -> Real

Get value of attribute.

*/

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

  call-seq:
    Matrix3_EPSILON -> Real

Get value of attribute.

*/
SWIGINTERN VALUE
_wrap_Matrix3_EPSILON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_float(static_cast< float >(Ogre::Matrix3::EPSILON));
  return _val;
}



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

  call-seq:
    ZERO -> Matrix3

Get value of attribute.

*/

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

  call-seq:
    Matrix3_ZERO -> Matrix3

Get value of attribute.

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



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

  call-seq:
    IDENTITY -> Matrix3

Get value of attribute.

*/

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

  call-seq:
    Matrix3_IDENTITY -> Matrix3

Get value of attribute.

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


/*
  Document-class: Ogre::Plane

  Proxy of C++ Ogre::Plane class


*/
swig_class SwigClassPlane;


/*
  Document-method: Ogre::Plane.new

  call-seq:
    Plane.new
    Plane.new(Plane rhs)
    Plane.new(Vector3 rkNormal, Real fConstant)
    Plane.new(Real a, Real b, Real c, Real d)
    Plane.new(Vector3 rkNormal, Vector3 rkPoint)
    Plane.new(Vector3 rkPoint0, Vector3 rkPoint1, Vector3 rkPoint2)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Plane *)new Ogre::Plane();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


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);
  {
    try {
      result = (Ogre::Plane *)new Ogre::Plane((Ogre::Plane const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Plane *)new Ogre::Plane((Ogre::Vector3 const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Plane *)new Ogre::Plane(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Plane *)new Ogre::Plane((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::Plane *)new Ogre::Plane((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::Side.NO_SIDE

  call-seq:
    NO_SIDE -> int

A class method.

*/

/*
  Document-method: Ogre::Side.POSITIVE_SIDE

  call-seq:
    POSITIVE_SIDE -> int

A class method.

*/

/*
  Document-method: Ogre::Side.NEGATIVE_SIDE

  call-seq:
    NEGATIVE_SIDE -> int

A class method.

*/

/*
  Document-method: Ogre::Side.BOTH_SIDE

  call-seq:
    BOTH_SIDE -> int

A class method.

*/

/*
  Document-method: Ogre::Plane.get_side

  call-seq:
    get_side(Vector3 rkPoint) -> int
    get_side(AxisAlignedBox rkBox) -> int
    get_side(Vector3 centre, Vector3 halfSize) -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Plane_get_side__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);
  {
    try {
      result = (Ogre::Plane::Side)((Ogre::Plane const *)arg1)->getSide((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_get_side__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);
  {
    try {
      result = (Ogre::Plane::Side)((Ogre::Plane const *)arg1)->getSide((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_get_side__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);
  {
    try {
      result = (Ogre::Plane::Side)((Ogre::Plane const *)arg1)->getSide((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Plane_get_side(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_get_side__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_get_side__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_get_side__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Plane.get_side", 
    "    Ogre::Plane::Side Plane.get_side(Ogre::Vector3 const &rkPoint)\n"
    "    Ogre::Plane::Side Plane.get_side(Ogre::AxisAlignedBox const &rkBox)\n"
    "    Ogre::Plane::Side Plane.get_side(Ogre::Vector3 const &centre, Ogre::Vector3 const &halfSize)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Plane.get_distance

  call-seq:
    get_distance(Vector3 rkPoint) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Plane_get_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Plane const *)arg1)->getDistance((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Plane.redefine

  call-seq:
    redefine(Vector3 rkPoint0, Vector3 rkPoint1, Vector3 rkPoint2)
    redefine(Vector3 rkNormal, Vector3 rkPoint)

An instance method.

*/
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);
  {
    try {
      (arg1)->redefine((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->redefine((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


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



/*
  Document-method: Ogre::Plane.project_vector

  call-seq:
    project_vector(Vector3 v) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Plane_project_vector(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);
  {
    try {
      result = ((Ogre::Plane const *)arg1)->projectVector((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Plane.normalise

  call-seq:
    normalise -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)(arg1)->normalise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Plane.normal

  call-seq:
    normal -> Vector3

Get value of attribute.

*/

/*
  Document-method: Ogre::Plane.normal=

  call-seq:
    normal=(x) -> Vector3

Set new value for attribute.

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



/*
  Document-method: Ogre::Plane.d

  call-seq:
    d -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Plane.d=

  call-seq:
    d=(x) -> Real

Set new value for attribute.

*/
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);
  {
    try {
      result = (bool)((Ogre::Plane const *)arg1)->operator ==((Ogre::Plane const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Plane(Ogre::Plane *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::Matrix4

  Proxy of C++ Ogre::Matrix4 class


*/
swig_class SwigClassMatrix4;


/*
  Document-method: Ogre::Matrix4.new

  call-seq:
    Matrix4.new
    Matrix4.new(Real m00, Real m01, Real m02, Real m03, Real m10, Real m11, 
    Real m12, Real m13, Real m20, Real m21, 
    Real m22, Real m23, Real m30, Real m31, Real m32, 
    Real m33)
    Matrix4.new(Matrix3 m3x3)
    Matrix4.new(Quaternion rot)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Matrix4 *)new Ogre::Matrix4();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Matrix4 *)new Ogre::Matrix4((Ogre::Matrix3 const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Matrix4 *)new Ogre::Matrix4((Ogre::Quaternion const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::Matrix4.swap

  call-seq:
    swap(Matrix4 other)

An instance method.

*/
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);
  {
    try {
      (arg1)->swap(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.concatenate

  call-seq:
    concatenate(Matrix4 m2) -> Matrix4

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->concatenate((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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:
    *(Matrix4 m2) -> Matrix4
    *(Vector3 v) -> Vector3
    *(Vector4 v) -> Vector4
    *(Plane p) -> Plane
    *(Real scalar) -> Matrix4

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->operator *((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->operator *((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->operator *((Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->operator *((Ogre::Plane const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->operator +((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->operator -((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = (bool)((Ogre::Matrix4 const *)arg1)->operator ==((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.transpose

  call-seq:
    transpose -> Matrix4

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->transpose();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.set_trans

  call-seq:
    set_trans(Vector3 v)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_set_trans(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);
  {
    try {
      (arg1)->setTrans((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.get_trans

  call-seq:
    get_trans -> Vector3
    get_trans(Vector3 v) -> Matrix4
    get_trans(Real t_x, Real t_y, Real t_z) -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_get_trans__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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->getTrans();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.make_trans

  call-seq:
    make_trans(Vector3 v)
    make_trans(Real tx, Real ty, Real tz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_make_trans__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);
  {
    try {
      (arg1)->makeTrans((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_make_trans__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);
  {
    try {
      (arg1)->makeTrans(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Matrix4_make_trans(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_make_trans__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_make_trans__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Matrix4.make_trans", 
    "    void Matrix4.make_trans(Ogre::Vector3 const &v)\n"
    "    void Matrix4.make_trans(Ogre::Real tx, Ogre::Real ty, Ogre::Real tz)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.get_trans

  call-seq:
    get_trans -> Vector3
    get_trans(Vector3 v) -> Matrix4
    get_trans(Real t_x, Real t_y, Real t_z) -> Matrix4

A class method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_get_trans__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);
  {
    try {
      result = Ogre::Matrix4::getTrans((Ogre::Vector3 const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_get_trans__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);
  {
    try {
      result = Ogre::Matrix4::getTrans(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_get_trans(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_get_trans__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_get_trans__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_get_trans__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Matrix4.get_trans", 
    "    Ogre::Matrix4 Matrix4.get_trans(Ogre::Matrix4 const *self)\n"
    "    Ogre::Matrix4 Matrix4.get_trans(Ogre::Vector3 const &v)\n"
    "    Ogre::Matrix4 Matrix4.get_trans(Ogre::Real t_x, Ogre::Real t_y, Ogre::Real t_z)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.set_scale

  call-seq:
    set_scale(Vector3 v)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_set_scale(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);
  {
    try {
      (arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.get_scale

  call-seq:
    get_scale(Vector3 v) -> Matrix4
    get_scale(Real s_x, Real s_y, Real s_z) -> Matrix4

A class method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_get_scale__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);
  {
    try {
      result = Ogre::Matrix4::getScale((Ogre::Vector3 const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_get_scale__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);
  {
    try {
      result = Ogre::Matrix4::getScale(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_get_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 == 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_get_scale__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_get_scale__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Matrix4.get_scale", 
    "    Ogre::Matrix4 Matrix4.get_scale(Ogre::Vector3 const &v)\n"
    "    Ogre::Matrix4 Matrix4.get_scale(Ogre::Real s_x, Ogre::Real s_y, Ogre::Real s_z)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.extract_3x_3matrix

  call-seq:
    extract_3x_3matrix(Matrix3 m3x3)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_extract_3x_3matrix(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);
  {
    try {
      ((Ogre::Matrix4 const *)arg1)->extract3x3Matrix(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.has_scale

  call-seq:
    has_scale -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_has_scale(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);
  {
    try {
      result = (bool)((Ogre::Matrix4 const *)arg1)->hasScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.has_negative_scale

  call-seq:
    has_negative_scale -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_has_negative_scale(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);
  {
    try {
      result = (bool)((Ogre::Matrix4 const *)arg1)->hasNegativeScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.extract_quaternion

  call-seq:
    extract_quaternion -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_extract_quaternion(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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->extractQuaternion();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.ZERO

  call-seq:
    ZERO -> Matrix4

Get value of attribute.

*/

/*
  Document-method: Ogre::Matrix4.Matrix4_ZERO

  call-seq:
    Matrix4_ZERO -> Matrix4

Get value of attribute.

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



/*
  Document-method: Ogre::Matrix4.ZEROAFFINE

  call-seq:
    ZEROAFFINE -> Matrix4

Get value of attribute.

*/

/*
  Document-method: Ogre::Matrix4.Matrix4_ZEROAFFINE

  call-seq:
    Matrix4_ZEROAFFINE -> Matrix4

Get value of attribute.

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



/*
  Document-method: Ogre::Matrix4.IDENTITY

  call-seq:
    IDENTITY -> Matrix4

Get value of attribute.

*/

/*
  Document-method: Ogre::Matrix4.Matrix4_IDENTITY

  call-seq:
    Matrix4_IDENTITY -> Matrix4

Get value of attribute.

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



/*
  Document-method: Ogre::Matrix4.CLIPSPACE2DTOIMAGESPACE

  call-seq:
    CLIPSPACE2DTOIMAGESPACE -> Matrix4

Get value of attribute.

*/

/*
  Document-method: Ogre::Matrix4.Matrix4_CLIPSPACE2DTOIMAGESPACE

  call-seq:
    Matrix4_CLIPSPACE2DTOIMAGESPACE -> Matrix4

Get value of attribute.

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



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

  call-seq:
    *(Matrix4 m2) -> Matrix4
    *(Vector3 v) -> Vector3
    *(Vector4 v) -> Vector4
    *(Plane p) -> Plane
    *(Real scalar) -> Matrix4

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->operator *(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Matrix4.adjoint

  call-seq:
    adjoint -> Matrix4

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->adjoint();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.determinant

  call-seq:
    determinant -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)((Ogre::Matrix4 const *)arg1)->determinant();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.inverse

  call-seq:
    inverse -> Matrix4

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->inverse();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.make_transform

  call-seq:
    make_transform(Vector3 position, Vector3 scale, Quaternion orientation)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_make_transform(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);
  {
    try {
      (arg1)->makeTransform((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.make_inverse_transform

  call-seq:
    make_inverse_transform(Vector3 position, Vector3 scale, Quaternion orientation)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_make_inverse_transform(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);
  {
    try {
      (arg1)->makeInverseTransform((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.decomposition

  call-seq:
    decomposition(Vector3 position, Vector3 scale, Quaternion orientation)

An instance method.

*/
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);
  {
    try {
      ((Ogre::Matrix4 const *)arg1)->decomposition(*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.is_affine

  call-seq:
    is_affine -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_is_affine(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);
  {
    try {
      result = (bool)((Ogre::Matrix4 const *)arg1)->isAffine();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.inverse_affine

  call-seq:
    inverse_affine -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_inverse_affine(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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->inverseAffine();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.concatenate_affine

  call-seq:
    concatenate_affine(Matrix4 m2) -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_concatenate_affine(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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->concatenateAffine((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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.transform_affine

  call-seq:
    transform_affine(Vector3 v) -> Vector3
    transform_affine(Vector4 v) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Matrix4_transform_affine__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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->transformAffine((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_transform_affine__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);
  {
    try {
      result = ((Ogre::Matrix4 const *)arg1)->transformAffine((Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Matrix4_transform_affine(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_transform_affine__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_transform_affine__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Matrix4.transform_affine", 
    "    Ogre::Vector4 Matrix4.transform_affine(Ogre::Vector3 const &v)\n"
    "    Ogre::Vector4 Matrix4.transform_affine(Ogre::Vector4 const &v)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Matrix4(Ogre::Matrix4 *arg1) {
    delete arg1;
}


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

  call-seq:
    *(Real a, Radian b) -> Radian
    *(Real a, Degree b) -> Degree
    *(Vector4 v, Matrix4 mat) -> Vector4

A module function.

*/
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);
  {
    try {
      result = Ogre::operator *((Ogre::Vector4 const &)*arg1,(Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
}



/*
  Document-class: Ogre::SimpleSpline

  Proxy of C++ Ogre::SimpleSpline class


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


/*
  Document-method: Ogre::SimpleSpline.new

  call-seq:
    SimpleSpline.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SimpleSpline *)new Ogre::SimpleSpline();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SimpleSpline(Ogre::SimpleSpline *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SimpleSpline.add_point

  call-seq:
    add_point(Vector3 p)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleSpline_add_point(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);
  {
    try {
      (arg1)->addPoint((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleSpline.get_point

  call-seq:
    get_point(unsigned short index) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleSpline_get_point(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::SimpleSpline const *)arg1)->getPoint(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleSpline.get_num_points

  call-seq:
    get_num_points -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleSpline_get_num_points(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);
  {
    try {
      result = (unsigned short)((Ogre::SimpleSpline const *)arg1)->getNumPoints();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleSpline.update_point

  call-seq:
    update_point(unsigned short index, Vector3 value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleSpline_update_point(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);
  {
    try {
      (arg1)->updatePoint(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleSpline.interpolate

  call-seq:
    interpolate(Real t) -> Vector3
    interpolate(unsigned int fromIndex, Real t) -> Vector3

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::SimpleSpline const *)arg1)->interpolate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = ((Ogre::SimpleSpline const *)arg1)->interpolate(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::SimpleSpline.set_auto_calculate

  call-seq:
    set_auto_calculate(bool autoCalc)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleSpline_set_auto_calculate(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);
  {
    try {
      (arg1)->setAutoCalculate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleSpline.recalc_tangents

  call-seq:
    recalc_tangents

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleSpline_recalc_tangents(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);
  {
    try {
      (arg1)->recalcTangents();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RotationalSpline

  Proxy of C++ Ogre::RotationalSpline class


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


/*
  Document-method: Ogre::RotationalSpline.new

  call-seq:
    RotationalSpline.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::RotationalSpline *)new Ogre::RotationalSpline();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RotationalSpline(Ogre::RotationalSpline *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RotationalSpline.add_point

  call-seq:
    add_point(Quaternion p)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RotationalSpline_add_point(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);
  {
    try {
      (arg1)->addPoint((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RotationalSpline.get_point

  call-seq:
    get_point(unsigned short index) -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_RotationalSpline_get_point(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);
  {
    try {
      result = (Ogre::Quaternion *) &((Ogre::RotationalSpline const *)arg1)->getPoint(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RotationalSpline.get_num_points

  call-seq:
    get_num_points -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_RotationalSpline_get_num_points(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);
  {
    try {
      result = (unsigned short)((Ogre::RotationalSpline const *)arg1)->getNumPoints();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RotationalSpline.update_point

  call-seq:
    update_point(unsigned short index, Quaternion value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RotationalSpline_update_point(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);
  {
    try {
      (arg1)->updatePoint(arg2,(Ogre::Quaternion const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RotationalSpline.interpolate

  call-seq:
    interpolate(Real t, bool useShortestPath=true) -> Quaternion
    interpolate(Real t) -> Quaternion
    interpolate(unsigned int fromIndex, Real t, bool useShortestPath=true) -> Quaternion
    interpolate(unsigned int fromIndex, Real t) -> Quaternion

An instance method.

*/
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);
  {
    try {
      result = (arg1)->interpolate(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->interpolate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (arg1)->interpolate(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = (arg1)->interpolate(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::RotationalSpline.set_auto_calculate

  call-seq:
    set_auto_calculate(bool autoCalc)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RotationalSpline_set_auto_calculate(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);
  {
    try {
      (arg1)->setAutoCalculate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RotationalSpline.recalc_tangents

  call-seq:
    recalc_tangents

An instance method.

*/
SWIGINTERN VALUE
_wrap_RotationalSpline_recalc_tangents(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);
  {
    try {
      (arg1)->recalcTangents();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::HardwareBuffer

  Proxy of C++ Ogre::HardwareBuffer class


*/
swig_class SwigClassHardwareBuffer;


/*
  Document-method: Ogre::Usage.HBU_STATIC

  call-seq:
    HBU_STATIC -> int

A class method.

*/

/*
  Document-method: Ogre::Usage.HBU_DYNAMIC

  call-seq:
    HBU_DYNAMIC -> int

A class method.

*/

/*
  Document-method: Ogre::Usage.HBU_WRITE_ONLY

  call-seq:
    HBU_WRITE_ONLY -> int

A class method.

*/

/*
  Document-method: Ogre::Usage.HBU_DISCARDABLE

  call-seq:
    HBU_DISCARDABLE -> int

A class method.

*/

/*
  Document-method: Ogre::Usage.HBU_STATIC_WRITE_ONLY

  call-seq:
    HBU_STATIC_WRITE_ONLY -> int

A class method.

*/

/*
  Document-method: Ogre::Usage.HBU_DYNAMIC_WRITE_ONLY

  call-seq:
    HBU_DYNAMIC_WRITE_ONLY -> int

A class method.

*/

/*
  Document-method: Ogre::Usage.HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE

  call-seq:
    HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE -> int

A class method.

*/

/*
  Document-method: Ogre::LockOptions.HBL_NORMAL

  call-seq:
    HBL_NORMAL -> int

A class method.

*/

/*
  Document-method: Ogre::LockOptions.HBL_DISCARD

  call-seq:
    HBL_DISCARD -> int

A class method.

*/

/*
  Document-method: Ogre::LockOptions.HBL_READ_ONLY

  call-seq:
    HBL_READ_ONLY -> int

A class method.

*/

/*
  Document-method: Ogre::LockOptions.HBL_NO_OVERWRITE

  call-seq:
    HBL_NO_OVERWRITE -> int

A class method.

*/
SWIGINTERN void
free_Ogre_HardwareBuffer(Ogre::HardwareBuffer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::HardwareBuffer.lock

  call-seq:
    lock(size_t offset, size_t length, LockOptions options) -> void
    lock(LockOptions options)

An instance method.

*/
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);
  {
    try {
      result = (void *)(arg1)->lock(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (void *)(arg1)->lock(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::HardwareBuffer.unlock

  call-seq:
    unlock

An instance method.

*/
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);
  {
    try {
      (arg1)->unlock();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBuffer.read_data

  call-seq:
    read_data(size_t offset, size_t length, void pDest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBuffer_read_data(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] )); 
  }
  {
    try {
      (arg1)->readData(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBuffer.write_data

  call-seq:
    write_data(size_t offset, size_t length, void pSource, bool discardWholeBuffer=false)
    write_data(size_t offset, size_t length, void pSource)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBuffer_write_data__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);
  {
    try {
      (arg1)->writeData(arg2,arg3,(void const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_write_data__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] )); 
  }
  {
    try {
      (arg1)->writeData(arg2,arg3,(void const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBuffer_write_data(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_write_data__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_write_data__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBuffer.write_data", 
    "    void HardwareBuffer.write_data(size_t offset, size_t length, void const *pSource, bool discardWholeBuffer)\n"
    "    void HardwareBuffer.write_data(size_t offset, size_t length, void const *pSource)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBuffer.copy_data

  call-seq:
    copy_data(HardwareBuffer srcBuffer, size_t srcOffset, size_t dstOffset, 
    size_t length, bool discardWholeBuffer=false)
    copy_data(HardwareBuffer srcBuffer, size_t srcOffset, size_t dstOffset, 
    size_t length)
    copy_data(HardwareBuffer srcBuffer)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBuffer_copy_data__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);
  {
    try {
      (arg1)->copyData(*arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_copy_data__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);
  {
    try {
      (arg1)->copyData(*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_copy_data__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);
  {
    try {
      (arg1)->copyData(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBuffer_copy_data(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_copy_data__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_copy_data__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_copy_data__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "HardwareBuffer.copy_data", 
    "    void HardwareBuffer.copy_data(Ogre::HardwareBuffer &srcBuffer, size_t srcOffset, size_t dstOffset, size_t length, bool discardWholeBuffer)\n"
    "    void HardwareBuffer.copy_data(Ogre::HardwareBuffer &srcBuffer, size_t srcOffset, size_t dstOffset, size_t length)\n"
    "    void HardwareBuffer.copy_data(Ogre::HardwareBuffer &srcBuffer)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBuffer._update_from_shadow

  call-seq:
    _update_from_shadow

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBuffer__update_from_shadow(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);
  {
    try {
      (arg1)->_updateFromShadow();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBuffer.get_size_in_bytes

  call-seq:
    get_size_in_bytes -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBuffer_get_size_in_bytes(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);
  {
    try {
      result = ((Ogre::HardwareBuffer const *)arg1)->getSizeInBytes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBuffer.get_usage

  call-seq:
    get_usage -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBuffer_get_usage(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);
  {
    try {
      result = (Ogre::HardwareBuffer::Usage)((Ogre::HardwareBuffer const *)arg1)->getUsage();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBuffer.is_system_memory

  call-seq:
    is_system_memory -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBuffer_is_system_memory(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);
  {
    try {
      result = (bool)((Ogre::HardwareBuffer const *)arg1)->isSystemMemory();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBuffer.has_shadow_buffer

  call-seq:
    has_shadow_buffer -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBuffer_has_shadow_buffer(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);
  {
    try {
      result = (bool)((Ogre::HardwareBuffer const *)arg1)->hasShadowBuffer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBuffer.is_locked

  call-seq:
    is_locked -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBuffer_is_locked(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);
  {
    try {
      result = (bool)((Ogre::HardwareBuffer const *)arg1)->isLocked();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBuffer.suppress_hardware_update

  call-seq:
    suppress_hardware_update(bool suppress)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBuffer_suppress_hardware_update(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);
  {
    try {
      (arg1)->suppressHardwareUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::HardwareVertexBuffer < Ogre::Ogre::HardwareBuffer

  Proxy of C++ Ogre::HardwareVertexBuffer class


*/
swig_class SwigClassHardwareVertexBuffer;

SWIGINTERN void
free_Ogre_HardwareVertexBuffer(Ogre::HardwareVertexBuffer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::HardwareVertexBuffer.get_manager

  call-seq:
    get_manager -> HardwareBufferManagerBase

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_get_manager(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);
  {
    try {
      result = (Ogre::HardwareBufferManagerBase *)((Ogre::HardwareVertexBuffer const *)arg1)->getManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareVertexBuffer.get_vertex_size

  call-seq:
    get_vertex_size -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_get_vertex_size(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);
  {
    try {
      result = ((Ogre::HardwareVertexBuffer const *)arg1)->getVertexSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareVertexBuffer.get_num_vertices

  call-seq:
    get_num_vertices -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_get_num_vertices(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);
  {
    try {
      result = ((Ogre::HardwareVertexBuffer const *)arg1)->getNumVertices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareVertexBuffer.get_is_instance_data

  call-seq:
    get_is_instance_data -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_get_is_instance_data(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);
  {
    try {
      result = (bool)((Ogre::HardwareVertexBuffer const *)arg1)->getIsInstanceData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareVertexBuffer.set_is_instance_data

  call-seq:
    set_is_instance_data(bool val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_set_is_instance_data(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);
  {
    try {
      (arg1)->setIsInstanceData(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareVertexBuffer.get_instance_data_step_rate

  call-seq:
    get_instance_data_step_rate -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_get_instance_data_step_rate(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);
  {
    try {
      result = ((Ogre::HardwareVertexBuffer const *)arg1)->getInstanceDataStepRate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareVertexBuffer.set_instance_data_step_rate

  call-seq:
    set_instance_data_step_rate(size_t val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_set_instance_data_step_rate(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);
  {
    try {
      (arg1)->setInstanceDataStepRate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::HardwareVertexBufferSharedPtr

  Proxy of C++ Ogre::HardwareVertexBufferSharedPtr class


*/
swig_class SwigClassHardwareVertexBufferSharedPtr;


/*
  Document-method: Ogre::HardwareVertexBufferSharedPtr.new

  call-seq:
    HardwareVertexBufferSharedPtr.new
    HardwareVertexBufferSharedPtr.new(HardwareVertexBuffer buf)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::HardwareVertexBufferSharedPtr *)new Ogre::HardwareVertexBufferSharedPtr();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::HardwareVertexBufferSharedPtr *)new Ogre::HardwareVertexBufferSharedPtr(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::VertexElement

  Proxy of C++ Ogre::VertexElement class


*/
swig_class SwigClassVertexElement;


/*
  Document-method: Ogre::VertexElement.new

  call-seq:
    VertexElement.new
    VertexElement.new(unsigned short source, size_t offset, VertexElementType theType, 
    VertexElementSemantic semantic, 
    unsigned short index=0)
    VertexElement.new(unsigned short source, size_t offset, VertexElementType theType, 
    VertexElementSemantic semantic)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::VertexElement *)new Ogre::VertexElement();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::VertexElement *)new Ogre::VertexElement(arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::VertexElement *)new Ogre::VertexElement(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::VertexElement.get_source

  call-seq:
    get_source -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_get_source(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);
  {
    try {
      result = (unsigned short)((Ogre::VertexElement const *)arg1)->getSource();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.get_offset

  call-seq:
    get_offset -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_get_offset(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);
  {
    try {
      result = ((Ogre::VertexElement const *)arg1)->getOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.get_type

  call-seq:
    get_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_get_type(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);
  {
    try {
      result = (Ogre::VertexElementType)((Ogre::VertexElement const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.get_semantic

  call-seq:
    get_semantic -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_get_semantic(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);
  {
    try {
      result = (Ogre::VertexElementSemantic)((Ogre::VertexElement const *)arg1)->getSemantic();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.get_index

  call-seq:
    get_index -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_get_index(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);
  {
    try {
      result = (unsigned short)((Ogre::VertexElement const *)arg1)->getIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.get_size

  call-seq:
    get_size -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_get_size(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);
  {
    try {
      result = ((Ogre::VertexElement const *)arg1)->getSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.get_type_size

  call-seq:
    get_type_size(VertexElementType etype) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_get_type_size(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);
  {
    try {
      result = Ogre::VertexElement::getTypeSize(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.get_type_count

  call-seq:
    get_type_count(VertexElementType etype) -> unsigned short

A class method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_get_type_count(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);
  {
    try {
      result = (unsigned short)Ogre::VertexElement::getTypeCount(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.multiply_type_count

  call-seq:
    multiply_type_count(VertexElementType baseType, unsigned short count) -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_multiply_type_count(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);
  {
    try {
      result = (Ogre::VertexElementType)Ogre::VertexElement::multiplyTypeCount(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.get_base_type

  call-seq:
    get_base_type(VertexElementType multiType) -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_get_base_type(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);
  {
    try {
      result = (Ogre::VertexElementType)Ogre::VertexElement::getBaseType(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.convert_colour_value

  call-seq:
    convert_colour_value(VertexElementType srcType, VertexElementType dstType, 
    uint32 ptr)
    convert_colour_value(ColourValue src, VertexElementType dst) -> uint32

A class method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_convert_colour_value__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);
  {
    try {
      Ogre::VertexElement::convertColourValue(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_convert_colour_value__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);
  {
    try {
      result = (Ogre::uint32)Ogre::VertexElement::convertColourValue((Ogre::ColourValue const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexElement_convert_colour_value(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_convert_colour_value__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_convert_colour_value__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "VertexElement.convert_colour_value", 
    "    Ogre::uint32 VertexElement.convert_colour_value(Ogre::VertexElementType srcType, Ogre::VertexElementType dstType, Ogre::uint32 *ptr)\n"
    "    Ogre::uint32 VertexElement.convert_colour_value(Ogre::ColourValue const &src, Ogre::VertexElementType dst)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.get_best_colour_vertex_element_type

  call-seq:
    get_best_colour_vertex_element_type -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_get_best_colour_vertex_element_type(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;
  }
  {
    try {
      result = (Ogre::VertexElementType)Ogre::VertexElement::getBestColourVertexElementType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::VertexElement const *)arg1)->operator ==((Ogre::VertexElement const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.base_vertex_pointer_to_element

  call-seq:
    base_vertex_pointer_to_element(void pBase, void pElem)
    base_vertex_pointer_to_element(void pBase, float pElem)
    base_vertex_pointer_to_element(void pBase, RGBA pElem)
    base_vertex_pointer_to_element(void pBase, unsigned char pElem)
    base_vertex_pointer_to_element(void pBase, unsigned short pElem)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexElement_base_vertex_pointer_to_element__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);
  {
    try {
      ((Ogre::VertexElement const *)arg1)->baseVertexPointerToElement(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_base_vertex_pointer_to_element__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);
  {
    try {
      ((Ogre::VertexElement const *)arg1)->baseVertexPointerToElement(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_base_vertex_pointer_to_element__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);
  {
    try {
      ((Ogre::VertexElement const *)arg1)->baseVertexPointerToElement(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_base_vertex_pointer_to_element__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);
  {
    try {
      ((Ogre::VertexElement const *)arg1)->baseVertexPointerToElement(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_base_vertex_pointer_to_element__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);
  {
    try {
      ((Ogre::VertexElement const *)arg1)->baseVertexPointerToElement(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexElement_base_vertex_pointer_to_element(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_base_vertex_pointer_to_element__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_base_vertex_pointer_to_element__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_base_vertex_pointer_to_element__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_base_vertex_pointer_to_element__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_base_vertex_pointer_to_element__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "VertexElement.base_vertex_pointer_to_element", 
    "    void VertexElement.base_vertex_pointer_to_element(void *pBase, void **pElem)\n"
    "    void VertexElement.base_vertex_pointer_to_element(void *pBase, float **pElem)\n"
    "    void VertexElement.base_vertex_pointer_to_element(void *pBase, Ogre::RGBA **pElem)\n"
    "    void VertexElement.base_vertex_pointer_to_element(void *pBase, unsigned char **pElem)\n"
    "    void VertexElement.base_vertex_pointer_to_element(void *pBase, unsigned short **pElem)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexElement(Ogre::VertexElement *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::VertexDeclaration

  Proxy of C++ Ogre::VertexDeclaration class


*/
swig_class SwigClassVertexDeclaration;


/*
  Document-method: Ogre::VertexDeclaration.vertex_element_less

  call-seq:
    vertex_element_less(VertexElement e1, VertexElement e2) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_vertex_element_less(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);
  {
    try {
      result = (bool)Ogre::VertexDeclaration::vertexElementLess((Ogre::VertexElement const &)*arg1,(Ogre::VertexElement const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::VertexDeclaration.new

  call-seq:
    VertexDeclaration.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::VertexDeclaration *)new Ogre::VertexDeclaration();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexDeclaration(Ogre::VertexDeclaration *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::VertexDeclaration.get_element_count

  call-seq:
    get_element_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_get_element_count(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);
  {
    try {
      result = ((Ogre::VertexDeclaration const *)arg1)->getElementCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.get_elements

  call-seq:
    get_elements -> VertexElementList

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_get_elements(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);
  {
    try {
      result = (Ogre::VertexDeclaration::VertexElementList *) &((Ogre::VertexDeclaration const *)arg1)->getElements();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__listT_Ogre__VertexElement_Ogre__STLAllocatorT_Ogre__VertexElement_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.get_element

  call-seq:
    get_element(unsigned short index) -> VertexElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_get_element(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);
  {
    try {
      result = (Ogre::VertexElement *)((Ogre::VertexDeclaration const *)arg1)->getElement(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.sort

  call-seq:
    sort

An instance method.

*/
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);
  {
    try {
      (arg1)->sort();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.close_gaps_in_source

  call-seq:
    close_gaps_in_source

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_close_gaps_in_source(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);
  {
    try {
      (arg1)->closeGapsInSource();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.get_auto_organised_declaration

  call-seq:
    get_auto_organised_declaration(bool skeletalAnimation, bool vertexAnimation, bool vertexAnimationNormals) -> VertexDeclaration

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_get_auto_organised_declaration(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);
  {
    try {
      result = (Ogre::VertexDeclaration *)((Ogre::VertexDeclaration const *)arg1)->getAutoOrganisedDeclaration(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.get_max_source

  call-seq:
    get_max_source -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_get_max_source(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);
  {
    try {
      result = (unsigned short)((Ogre::VertexDeclaration const *)arg1)->getMaxSource();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.add_element

  call-seq:
    add_element(unsigned short source, size_t offset, VertexElementType theType, 
    VertexElementSemantic semantic, 
    unsigned short index=0) -> VertexElement
    add_element(unsigned short source, size_t offset, VertexElementType theType, 
    VertexElementSemantic semantic) -> VertexElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_add_element__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);
  {
    try {
      result = (Ogre::VertexElement *) &(arg1)->addElement(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_add_element__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);
  {
    try {
      result = (Ogre::VertexElement *) &(arg1)->addElement(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexDeclaration_add_element(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_add_element__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_add_element__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "VertexDeclaration.add_element", 
    "    Ogre::VertexElement const & VertexDeclaration.add_element(unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic, unsigned short index)\n"
    "    Ogre::VertexElement const & VertexDeclaration.add_element(unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.insert_element

  call-seq:
    insert_element(unsigned short atPosition, unsigned short source, size_t offset, 
    VertexElementType theType, VertexElementSemantic semantic, 
    unsigned short index=0) -> VertexElement
    insert_element(unsigned short atPosition, unsigned short source, size_t offset, 
    VertexElementType theType, VertexElementSemantic semantic) -> VertexElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_insert_element__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);
  {
    try {
      result = (Ogre::VertexElement *) &(arg1)->insertElement(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_insert_element__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);
  {
    try {
      result = (Ogre::VertexElement *) &(arg1)->insertElement(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexDeclaration_insert_element(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_insert_element__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_insert_element__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "VertexDeclaration.insert_element", 
    "    Ogre::VertexElement const & VertexDeclaration.insert_element(unsigned short atPosition, unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic, unsigned short index)\n"
    "    Ogre::VertexElement const & VertexDeclaration.insert_element(unsigned short atPosition, unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.remove_element

  call-seq:
    remove_element(unsigned short elem_index)
    remove_element(VertexElementSemantic semantic, unsigned short index=0)
    remove_element(VertexElementSemantic semantic)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_remove_element__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);
  {
    try {
      (arg1)->removeElement(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_remove_element__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);
  {
    try {
      (arg1)->removeElement(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_remove_element__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);
  {
    try {
      (arg1)->removeElement(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexDeclaration_remove_element(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_remove_element__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_remove_element__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_remove_element__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "VertexDeclaration.remove_element", 
    "    void VertexDeclaration.remove_element(unsigned short elem_index)\n"
    "    void VertexDeclaration.remove_element(Ogre::VertexElementSemantic semantic, unsigned short index)\n"
    "    void VertexDeclaration.remove_element(Ogre::VertexElementSemantic semantic)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.remove_all_elements

  call-seq:
    remove_all_elements

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_remove_all_elements(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);
  {
    try {
      (arg1)->removeAllElements();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.modify_element

  call-seq:
    modify_element(unsigned short elem_index, unsigned short source, size_t offset, 
    VertexElementType theType, VertexElementSemantic semantic, 
    unsigned short index=0)
    modify_element(unsigned short elem_index, unsigned short source, size_t offset, 
    VertexElementType theType, VertexElementSemantic semantic)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_modify_element__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);
  {
    try {
      (arg1)->modifyElement(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_modify_element__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);
  {
    try {
      (arg1)->modifyElement(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexDeclaration_modify_element(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_modify_element__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_modify_element__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "VertexDeclaration.modify_element", 
    "    void VertexDeclaration.modify_element(unsigned short elem_index, unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic, unsigned short index)\n"
    "    void VertexDeclaration.modify_element(unsigned short elem_index, unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.find_element_by_semantic

  call-seq:
    find_element_by_semantic(VertexElementSemantic sem, unsigned short index=0) -> VertexElement
    find_element_by_semantic(VertexElementSemantic sem) -> VertexElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_find_element_by_semantic__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);
  {
    try {
      result = (Ogre::VertexElement *)((Ogre::VertexDeclaration const *)arg1)->findElementBySemantic(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_find_element_by_semantic__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);
  {
    try {
      result = (Ogre::VertexElement *)((Ogre::VertexDeclaration const *)arg1)->findElementBySemantic(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexDeclaration_find_element_by_semantic(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_find_element_by_semantic__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_find_element_by_semantic__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "VertexDeclaration.find_element_by_semantic", 
    "    Ogre::VertexElement const * VertexDeclaration.find_element_by_semantic(Ogre::VertexElementSemantic sem, unsigned short index)\n"
    "    Ogre::VertexElement const * VertexDeclaration.find_element_by_semantic(Ogre::VertexElementSemantic sem)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.find_elements_by_source

  call-seq:
    find_elements_by_source(unsigned short source) -> VertexElementList

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_find_elements_by_source(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);
  {
    try {
      result = ((Ogre::VertexDeclaration const *)arg1)->findElementsBySource(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::VertexDeclaration.get_vertex_size

  call-seq:
    get_vertex_size(unsigned short source) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_get_vertex_size(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);
  {
    try {
      result = ((Ogre::VertexDeclaration const *)arg1)->getVertexSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.get_next_free_texture_coordinate

  call-seq:
    get_next_free_texture_coordinate -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_get_next_free_texture_coordinate(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);
  {
    try {
      result = (unsigned short)((Ogre::VertexDeclaration const *)arg1)->getNextFreeTextureCoordinate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::VertexDeclaration *)((Ogre::VertexDeclaration const *)arg1)->clone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      result = (Ogre::VertexDeclaration *)((Ogre::VertexDeclaration const *)arg1)->clone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      result = (bool)((Ogre::VertexDeclaration const *)arg1)->operator ==((Ogre::VertexDeclaration const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::VertexBufferBinding

  Proxy of C++ Ogre::VertexBufferBinding class


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


/*
  Document-method: Ogre::VertexBufferBinding.new

  call-seq:
    VertexBufferBinding.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::VertexBufferBinding *)new Ogre::VertexBufferBinding();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexBufferBinding(Ogre::VertexBufferBinding *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::VertexBufferBinding.set_binding

  call-seq:
    set_binding(unsigned short index, HardwareVertexBufferSharedPtr buffer)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexBufferBinding_set_binding(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);
  {
    try {
      (arg1)->setBinding(arg2,(Ogre::HardwareVertexBufferSharedPtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexBufferBinding.unset_binding

  call-seq:
    unset_binding(unsigned short index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexBufferBinding_unset_binding(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);
  {
    try {
      (arg1)->unsetBinding(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexBufferBinding.unset_all_bindings

  call-seq:
    unset_all_bindings

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexBufferBinding_unset_all_bindings(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);
  {
    try {
      (arg1)->unsetAllBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexBufferBinding.get_bindings

  call-seq:
    get_bindings -> VertexBufferBindingMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexBufferBinding_get_bindings(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);
  {
    try {
      result = (Ogre::VertexBufferBinding::VertexBufferBindingMap *) &((Ogre::VertexBufferBinding const *)arg1)->getBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::VertexBufferBinding.get_buffer

  call-seq:
    get_buffer(unsigned short index) -> HardwareVertexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexBufferBinding_get_buffer(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);
  {
    try {
      result = (Ogre::HardwareVertexBufferSharedPtr *) &((Ogre::VertexBufferBinding const *)arg1)->getBuffer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexBufferBinding.is_buffer_bound

  call-seq:
    is_buffer_bound(unsigned short index) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexBufferBinding_is_buffer_bound(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);
  {
    try {
      result = (bool)((Ogre::VertexBufferBinding const *)arg1)->isBufferBound(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexBufferBinding.get_buffer_count

  call-seq:
    get_buffer_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexBufferBinding_get_buffer_count(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);
  {
    try {
      result = ((Ogre::VertexBufferBinding const *)arg1)->getBufferCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexBufferBinding.get_next_index

  call-seq:
    get_next_index -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexBufferBinding_get_next_index(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);
  {
    try {
      result = (unsigned short)((Ogre::VertexBufferBinding const *)arg1)->getNextIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexBufferBinding.get_last_bound_index

  call-seq:
    get_last_bound_index -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexBufferBinding_get_last_bound_index(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);
  {
    try {
      result = (unsigned short)((Ogre::VertexBufferBinding const *)arg1)->getLastBoundIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexBufferBinding.has_gaps

  call-seq:
    has_gaps -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexBufferBinding_has_gaps(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);
  {
    try {
      result = (bool)((Ogre::VertexBufferBinding const *)arg1)->hasGaps();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexBufferBinding.close_gaps

  call-seq:
    close_gaps(BindingIndexMap bindingIndexMap)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexBufferBinding_close_gaps(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);
  {
    try {
      (arg1)->closeGaps(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexBufferBinding.get_has_instance_data

  call-seq:
    get_has_instance_data -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexBufferBinding_get_has_instance_data(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);
  {
    try {
      result = (bool)((Ogre::VertexBufferBinding const *)arg1)->getHasInstanceData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::KeyFrame

  Proxy of C++ Ogre::KeyFrame class


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


/*
  Document-method: Ogre::KeyFrame.new

  call-seq:
    KeyFrame.new(AnimationTrack parent, Real time)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::KeyFrame *)new Ogre::KeyFrame((Ogre::AnimationTrack const *)arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_KeyFrame(Ogre::KeyFrame *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::KeyFrame.get_time

  call-seq:
    get_time -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_KeyFrame_get_time(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);
  {
    try {
      result = (Ogre::Real)((Ogre::KeyFrame const *)arg1)->getTime();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::KeyFrame._clone

  call-seq:
    _clone(AnimationTrack newParent) -> KeyFrame

An instance method.

*/
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);
  {
    try {
      result = (Ogre::KeyFrame *)((Ogre::KeyFrame const *)arg1)->_clone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::NumericKeyFrame < Ogre::Ogre::KeyFrame

  Proxy of C++ Ogre::NumericKeyFrame class


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


/*
  Document-method: Ogre::NumericKeyFrame.new

  call-seq:
    NumericKeyFrame.new(AnimationTrack parent, Real time)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::NumericKeyFrame *)new Ogre::NumericKeyFrame((Ogre::AnimationTrack const *)arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_NumericKeyFrame(Ogre::NumericKeyFrame *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::NumericKeyFrame.get_value

  call-seq:
    get_value -> AnyNumeric

An instance method.

*/
SWIGINTERN VALUE
_wrap_NumericKeyFrame_get_value(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);
  {
    try {
      result = (Ogre::AnyNumeric *) &((Ogre::NumericKeyFrame const *)arg1)->getValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnyNumeric, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NumericKeyFrame.set_value

  call-seq:
    set_value(AnyNumeric val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_NumericKeyFrame_set_value(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);
  {
    try {
      (arg1)->setValue((Ogre::AnyNumeric const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NumericKeyFrame._clone

  call-seq:
    _clone(AnimationTrack newParent) -> KeyFrame

An instance method.

*/
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);
  {
    try {
      result = (Ogre::KeyFrame *)((Ogre::NumericKeyFrame const *)arg1)->_clone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::TransformKeyFrame < Ogre::Ogre::KeyFrame

  Proxy of C++ Ogre::TransformKeyFrame class


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


/*
  Document-method: Ogre::TransformKeyFrame.new

  call-seq:
    TransformKeyFrame.new(AnimationTrack parent, Real time)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::TransformKeyFrame *)new Ogre::TransformKeyFrame((Ogre::AnimationTrack const *)arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TransformKeyFrame(Ogre::TransformKeyFrame *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::TransformKeyFrame.set_translate

  call-seq:
    set_translate(Vector3 trans)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TransformKeyFrame_set_translate(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);
  {
    try {
      (arg1)->setTranslate((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TransformKeyFrame.get_translate

  call-seq:
    get_translate -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_TransformKeyFrame_get_translate(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::TransformKeyFrame const *)arg1)->getTranslate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TransformKeyFrame.set_scale

  call-seq:
    set_scale(Vector3 scale)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TransformKeyFrame_set_scale(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);
  {
    try {
      (arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TransformKeyFrame.get_scale

  call-seq:
    get_scale -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_TransformKeyFrame_get_scale(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::TransformKeyFrame const *)arg1)->getScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TransformKeyFrame.set_rotation

  call-seq:
    set_rotation(Quaternion rot)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TransformKeyFrame_set_rotation(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);
  {
    try {
      (arg1)->setRotation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TransformKeyFrame.get_rotation

  call-seq:
    get_rotation -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_TransformKeyFrame_get_rotation(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);
  {
    try {
      result = (Ogre::Quaternion *) &((Ogre::TransformKeyFrame const *)arg1)->getRotation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TransformKeyFrame._clone

  call-seq:
    _clone(AnimationTrack newParent) -> KeyFrame

An instance method.

*/
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);
  {
    try {
      result = (Ogre::KeyFrame *)((Ogre::TransformKeyFrame const *)arg1)->_clone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::VertexMorphKeyFrame < Ogre::Ogre::KeyFrame

  Proxy of C++ Ogre::VertexMorphKeyFrame class


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


/*
  Document-method: Ogre::VertexMorphKeyFrame.new

  call-seq:
    VertexMorphKeyFrame.new(AnimationTrack parent, Real time)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::VertexMorphKeyFrame *)new Ogre::VertexMorphKeyFrame((Ogre::AnimationTrack const *)arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexMorphKeyFrame(Ogre::VertexMorphKeyFrame *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::VertexMorphKeyFrame.set_vertex_buffer

  call-seq:
    set_vertex_buffer(HardwareVertexBufferSharedPtr buf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexMorphKeyFrame_set_vertex_buffer(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);
  {
    try {
      (arg1)->setVertexBuffer((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexMorphKeyFrame.get_vertex_buffer

  call-seq:
    get_vertex_buffer -> HardwareVertexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexMorphKeyFrame_get_vertex_buffer(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);
  {
    try {
      result = (Ogre::HardwareVertexBufferSharedPtr *) &((Ogre::VertexMorphKeyFrame const *)arg1)->getVertexBuffer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexMorphKeyFrame._clone

  call-seq:
    _clone(AnimationTrack newParent) -> KeyFrame

An instance method.

*/
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);
  {
    try {
      result = (Ogre::KeyFrame *)((Ogre::VertexMorphKeyFrame const *)arg1)->_clone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::VertexPoseKeyFrame < Ogre::Ogre::KeyFrame

  Proxy of C++ Ogre::VertexPoseKeyFrame class


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


/*
  Document-method: Ogre::VertexPoseKeyFrame.new

  call-seq:
    VertexPoseKeyFrame.new(AnimationTrack parent, Real time)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::VertexPoseKeyFrame *)new Ogre::VertexPoseKeyFrame((Ogre::AnimationTrack const *)arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexPoseKeyFrame(Ogre::VertexPoseKeyFrame *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::VertexPoseKeyFrame.add_pose_reference

  call-seq:
    add_pose_reference(ushort poseIndex, Real influence)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_add_pose_reference(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);
  {
    try {
      (arg1)->addPoseReference(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexPoseKeyFrame.update_pose_reference

  call-seq:
    update_pose_reference(ushort poseIndex, Real influence)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_update_pose_reference(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);
  {
    try {
      (arg1)->updatePoseReference(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexPoseKeyFrame.remove_pose_reference

  call-seq:
    remove_pose_reference(ushort poseIndex)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_remove_pose_reference(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);
  {
    try {
      (arg1)->removePoseReference(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexPoseKeyFrame.remove_all_pose_references

  call-seq:
    remove_all_pose_references

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_remove_all_pose_references(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);
  {
    try {
      (arg1)->removeAllPoseReferences();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexPoseKeyFrame.get_pose_references

  call-seq:
    get_pose_references -> PoseRefList

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_get_pose_references(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);
  {
    try {
      result = (Ogre::VertexPoseKeyFrame::PoseRefList *) &((Ogre::VertexPoseKeyFrame const *)arg1)->getPoseReferences();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexPoseKeyFrame.get_pose_reference_iterator

  call-seq:
    get_pose_reference_iterator -> PoseRefIterator
    get_pose_reference_iterator -> ConstPoseRefIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_get_pose_reference_iterator__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);
  {
    try {
      result = (arg1)->getPoseReferenceIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_pose_reference_iterator__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);
  {
    try {
      result = ((Ogre::VertexPoseKeyFrame const *)arg1)->getPoseReferenceIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_pose_reference_iterator(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_get_pose_reference_iterator__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_get_pose_reference_iterator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "VertexPoseKeyFrame.get_pose_reference_iterator", 
    "    Ogre::VertexPoseKeyFrame::ConstPoseRefIterator VertexPoseKeyFrame.get_pose_reference_iterator()\n"
    "    Ogre::VertexPoseKeyFrame::ConstPoseRefIterator VertexPoseKeyFrame.get_pose_reference_iterator()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::VertexPoseKeyFrame._clone

  call-seq:
    _clone(AnimationTrack newParent) -> KeyFrame

An instance method.

*/
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);
  {
    try {
      result = (Ogre::KeyFrame *)((Ogre::VertexPoseKeyFrame const *)arg1)->_clone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexPoseKeyFrame._apply_base_key_frame

  call-seq:
    _apply_base_key_frame(VertexPoseKeyFrame base)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame__apply_base_key_frame(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);
  {
    try {
      (arg1)->_applyBaseKeyFrame((Ogre::VertexPoseKeyFrame const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Pose

  Proxy of C++ Ogre::Pose class


*/
swig_class SwigClassPose;


/*
  Document-method: Ogre::Pose.new

  call-seq:
    Pose.new(ushort target, String name=BLANK)
    Pose.new(ushort target)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Pose *)new Ogre::Pose(arg1,(Ogre::String const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Pose *)new Ogre::Pose(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::Pose.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pose_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Pose const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pose.get_target

  call-seq:
    get_target -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pose_get_target(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::Pose const *)arg1)->getTarget();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pose.get_includes_normals

  call-seq:
    get_includes_normals -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pose_get_includes_normals(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);
  {
    try {
      result = (bool)((Ogre::Pose const *)arg1)->getIncludesNormals();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pose.add_vertex

  call-seq:
    add_vertex(size_t index, Vector3 offset)
    add_vertex(size_t index, Vector3 offset, Vector3 normal)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pose_add_vertex__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);
  {
    try {
      (arg1)->addVertex(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_add_vertex__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);
  {
    try {
      (arg1)->addVertex(arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pose_add_vertex(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_add_vertex__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_add_vertex__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Pose.add_vertex", 
    "    void Pose.add_vertex(size_t index, Ogre::Vector3 const &offset)\n"
    "    void Pose.add_vertex(size_t index, Ogre::Vector3 const &offset, Ogre::Vector3 const &normal)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pose.remove_vertex

  call-seq:
    remove_vertex(size_t index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pose_remove_vertex(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);
  {
    try {
      (arg1)->removeVertex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pose.clear_vertices

  call-seq:
    clear_vertices

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pose_clear_vertices(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);
  {
    try {
      (arg1)->clearVertices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pose.get_vertex_offset_iterator

  call-seq:
    get_vertex_offset_iterator -> ConstVertexOffsetIterator
    get_vertex_offset_iterator -> VertexOffsetIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pose_get_vertex_offset_iterator__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);
  {
    try {
      result = ((Ogre::Pose const *)arg1)->getVertexOffsetIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_vertex_offset_iterator__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);
  {
    try {
      result = (arg1)->getVertexOffsetIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_vertex_offset_iterator(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_get_vertex_offset_iterator__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_get_vertex_offset_iterator__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Pose.get_vertex_offset_iterator", 
    "    Ogre::Pose::VertexOffsetIterator Pose.get_vertex_offset_iterator()\n"
    "    Ogre::Pose::VertexOffsetIterator Pose.get_vertex_offset_iterator()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pose.get_vertex_offsets

  call-seq:
    get_vertex_offsets -> VertexOffsetMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pose_get_vertex_offsets(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);
  {
    try {
      result = (Ogre::Pose::VertexOffsetMap *) &((Ogre::Pose const *)arg1)->getVertexOffsets();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::Pose.get_normals_iterator

  call-seq:
    get_normals_iterator -> ConstNormalsIterator
    get_normals_iterator -> NormalsIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pose_get_normals_iterator__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);
  {
    try {
      result = ((Ogre::Pose const *)arg1)->getNormalsIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_normals_iterator__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);
  {
    try {
      result = (arg1)->getNormalsIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_normals_iterator(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_get_normals_iterator__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_get_normals_iterator__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Pose.get_normals_iterator", 
    "    Ogre::Pose::NormalsIterator Pose.get_normals_iterator()\n"
    "    Ogre::Pose::NormalsIterator Pose.get_normals_iterator()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pose.get_normals

  call-seq:
    get_normals -> NormalsMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pose_get_normals(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);
  {
    try {
      result = (Ogre::Pose::NormalsMap *) &((Ogre::Pose const *)arg1)->getNormals();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::Pose._get_hardware_vertex_buffer

  call-seq:
    _get_hardware_vertex_buffer(VertexData origData) -> HardwareVertexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pose__get_hardware_vertex_buffer(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);
  {
    try {
      result = (Ogre::HardwareVertexBufferSharedPtr *) &((Ogre::Pose const *)arg1)->_getHardwareVertexBuffer((Ogre::VertexData const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::Pose *)((Ogre::Pose const *)arg1)->clone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::TimeIndex

  Proxy of C++ Ogre::TimeIndex class


*/
swig_class SwigClassTimeIndex;


/*
  Document-method: Ogre::TimeIndex.new

  call-seq:
    TimeIndex.new(Real timePos)
    TimeIndex.new(Real timePos, uint keyIndex)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::TimeIndex *)new Ogre::TimeIndex(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::TimeIndex *)new Ogre::TimeIndex(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::TimeIndex.has_key_index

  call-seq:
    has_key_index -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TimeIndex_has_key_index(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);
  {
    try {
      result = (bool)((Ogre::TimeIndex const *)arg1)->hasKeyIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TimeIndex.get_time_pos

  call-seq:
    get_time_pos -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TimeIndex_get_time_pos(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TimeIndex const *)arg1)->getTimePos();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TimeIndex.get_key_index

  call-seq:
    get_key_index -> uint

An instance method.

*/
SWIGINTERN VALUE
_wrap_TimeIndex_get_key_index(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);
  {
    try {
      result = (Ogre::uint)((Ogre::TimeIndex const *)arg1)->getKeyIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::AnimationTrack

  Proxy of C++ Ogre::AnimationTrack class


*/
swig_class SwigClassAnimationTrack;

SWIGINTERN void
free_Ogre_AnimationTrack(Ogre::AnimationTrack *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::AnimationTrack.get_handle

  call-seq:
    get_handle -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack_get_handle(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);
  {
    try {
      result = (unsigned short)((Ogre::AnimationTrack const *)arg1)->getHandle();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack.get_num_key_frames

  call-seq:
    get_num_key_frames -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack_get_num_key_frames(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);
  {
    try {
      result = (unsigned short)((Ogre::AnimationTrack const *)arg1)->getNumKeyFrames();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack.get_key_frame

  call-seq:
    get_key_frame(unsigned short index) -> KeyFrame

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack_get_key_frame(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);
  {
    try {
      result = (Ogre::KeyFrame *)((Ogre::AnimationTrack const *)arg1)->getKeyFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack.get_key_frames_at_time

  call-seq:
    get_key_frames_at_time(TimeIndex timeIndex, KeyFrame keyFrame1, KeyFrame keyFrame2, 
    unsigned short firstKeyIndex=0) -> Real
    get_key_frames_at_time(TimeIndex timeIndex, KeyFrame keyFrame1, KeyFrame keyFrame2) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack_get_key_frames_at_time__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);
  {
    try {
      result = (Ogre::Real)((Ogre::AnimationTrack const *)arg1)->getKeyFramesAtTime((Ogre::TimeIndex const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_get_key_frames_at_time__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);
  {
    try {
      result = (Ogre::Real)((Ogre::AnimationTrack const *)arg1)->getKeyFramesAtTime((Ogre::TimeIndex const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimationTrack_get_key_frames_at_time(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_get_key_frames_at_time__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_get_key_frames_at_time__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "AnimationTrack.get_key_frames_at_time", 
    "    Ogre::Real AnimationTrack.get_key_frames_at_time(Ogre::TimeIndex const &timeIndex, Ogre::KeyFrame **keyFrame1, Ogre::KeyFrame **keyFrame2, unsigned short *firstKeyIndex)\n"
    "    Ogre::Real AnimationTrack.get_key_frames_at_time(Ogre::TimeIndex const &timeIndex, Ogre::KeyFrame **keyFrame1, Ogre::KeyFrame **keyFrame2)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack.create_key_frame

  call-seq:
    create_key_frame(Real timePos) -> KeyFrame

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack_create_key_frame(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);
  {
    try {
      result = (Ogre::KeyFrame *)(arg1)->createKeyFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack.remove_key_frame

  call-seq:
    remove_key_frame(unsigned short index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack_remove_key_frame(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);
  {
    try {
      (arg1)->removeKeyFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack.remove_all_key_frames

  call-seq:
    remove_all_key_frames

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack_remove_all_key_frames(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);
  {
    try {
      (arg1)->removeAllKeyFrames();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack.get_interpolated_key_frame

  call-seq:
    get_interpolated_key_frame(TimeIndex timeIndex, KeyFrame kf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack_get_interpolated_key_frame(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);
  {
    try {
      ((Ogre::AnimationTrack const *)arg1)->getInterpolatedKeyFrame((Ogre::TimeIndex const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack.apply

  call-seq:
    apply(TimeIndex timeIndex, Real weight=1.0, Real scale=1.0)
    apply(TimeIndex timeIndex, Real weight=1.0)
    apply(TimeIndex timeIndex)

An instance method.

*/
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);
  {
    try {
      (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply((Ogre::TimeIndex const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::AnimationTrack._key_frame_data_changed

  call-seq:
    _key_frame_data_changed

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack__key_frame_data_changed(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);
  {
    try {
      ((Ogre::AnimationTrack const *)arg1)->_keyFrameDataChanged();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack.has_non_zero_key_frames

  call-seq:
    has_non_zero_key_frames -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack_has_non_zero_key_frames(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);
  {
    try {
      result = (bool)((Ogre::AnimationTrack const *)arg1)->hasNonZeroKeyFrames();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack.optimise

  call-seq:
    optimise

An instance method.

*/
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);
  {
    try {
      (arg1)->optimise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack._collect_key_frame_times

  call-seq:
    _collect_key_frame_times(Ogre::vector<(Ogre::Real,Ogre::STLAllocator<(Ogre::Real,Ogre::GeneralAllocPolicy)>)>::type keyFrameTimes)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack__collect_key_frame_times(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);
  {
    try {
      (arg1)->_collectKeyFrameTimes(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack._build_key_frame_index_map

  call-seq:
    _build_key_frame_index_map(Ogre::vector<(Ogre::Real,Ogre::STLAllocator<(Ogre::Real,Ogre::GeneralAllocPolicy)>)>::type keyFrameTimes)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack__build_key_frame_index_map(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);
  {
    try {
      (arg1)->_buildKeyFrameIndexMap((Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack._apply_base_key_frame

  call-seq:
    _apply_base_key_frame(KeyFrame base)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack__apply_base_key_frame(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);
  {
    try {
      (arg1)->_applyBaseKeyFrame((Ogre::KeyFrame const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack.set_listener

  call-seq:
    set_listener(Listener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack_set_listener(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);
  {
    try {
      (arg1)->setListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationTrack.get_parent

  call-seq:
    get_parent -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationTrack_get_parent(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);
  {
    try {
      result = (Ogre::Animation *)((Ogre::AnimationTrack const *)arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::NumericAnimationTrack < Ogre::Ogre::AnimationTrack

  Proxy of C++ Ogre::NumericAnimationTrack class


*/
swig_class SwigClassNumericAnimationTrack;


/*
  Document-method: Ogre::NumericAnimationTrack.new

  call-seq:
    NumericAnimationTrack.new(Animation parent, unsigned short handle)
    NumericAnimationTrack.new(Animation parent, unsigned short handle, AnimableValuePtr target)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::NumericAnimationTrack *)new Ogre::NumericAnimationTrack(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::NumericAnimationTrack *)new Ogre::NumericAnimationTrack(arg1,arg2,*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::NumericAnimationTrack.create_numeric_key_frame

  call-seq:
    create_numeric_key_frame(Real timePos) -> NumericKeyFrame

An instance method.

*/
SWIGINTERN VALUE
_wrap_NumericAnimationTrack_create_numeric_key_frame(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);
  {
    try {
      result = (Ogre::NumericKeyFrame *)(arg1)->createNumericKeyFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NumericKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NumericAnimationTrack.get_interpolated_key_frame

  call-seq:
    get_interpolated_key_frame(TimeIndex timeIndex, KeyFrame kf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_NumericAnimationTrack_get_interpolated_key_frame(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);
  {
    try {
      ((Ogre::NumericAnimationTrack const *)arg1)->getInterpolatedKeyFrame((Ogre::TimeIndex const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NumericAnimationTrack.apply

  call-seq:
    apply(TimeIndex timeIndex, Real weight=1.0, Real scale=1.0)
    apply(TimeIndex timeIndex, Real weight=1.0)
    apply(TimeIndex timeIndex)

An instance method.

*/
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);
  {
    try {
      (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply((Ogre::TimeIndex const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::NumericAnimationTrack.apply_to_animable

  call-seq:
    apply_to_animable(AnimableValuePtr anim, TimeIndex timeIndex, Real weight=1.0, 
    Real scale=1.0)
    apply_to_animable(AnimableValuePtr anim, TimeIndex timeIndex, Real weight=1.0)
    apply_to_animable(AnimableValuePtr anim, TimeIndex timeIndex)

An instance method.

*/
SWIGINTERN VALUE
_wrap_NumericAnimationTrack_apply_to_animable__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);
  {
    try {
      (arg1)->applyToAnimable((Ogre::AnimableValuePtr const &)*arg2,(Ogre::TimeIndex const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_apply_to_animable__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);
  {
    try {
      (arg1)->applyToAnimable((Ogre::AnimableValuePtr const &)*arg2,(Ogre::TimeIndex const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_apply_to_animable__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);
  {
    try {
      (arg1)->applyToAnimable((Ogre::AnimableValuePtr const &)*arg2,(Ogre::TimeIndex const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_NumericAnimationTrack_apply_to_animable(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_apply_to_animable__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_apply_to_animable__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_apply_to_animable__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "NumericAnimationTrack.apply_to_animable", 
    "    void NumericAnimationTrack.apply_to_animable(Ogre::AnimableValuePtr const &anim, Ogre::TimeIndex const &timeIndex, Ogre::Real weight, Ogre::Real scale)\n"
    "    void NumericAnimationTrack.apply_to_animable(Ogre::AnimableValuePtr const &anim, Ogre::TimeIndex const &timeIndex, Ogre::Real weight)\n"
    "    void NumericAnimationTrack.apply_to_animable(Ogre::AnimableValuePtr const &anim, Ogre::TimeIndex const &timeIndex)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::NumericAnimationTrack.get_associated_animable

  call-seq:
    get_associated_animable -> AnimableValuePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_NumericAnimationTrack_get_associated_animable(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);
  {
    try {
      result = (Ogre::AnimableValuePtr *) &((Ogre::NumericAnimationTrack const *)arg1)->getAssociatedAnimable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NumericAnimationTrack.set_associated_animable

  call-seq:
    set_associated_animable(AnimableValuePtr val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_NumericAnimationTrack_set_associated_animable(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);
  {
    try {
      (arg1)->setAssociatedAnimable((Ogre::AnimableValuePtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NumericAnimationTrack.get_numeric_key_frame

  call-seq:
    get_numeric_key_frame(unsigned short index) -> NumericKeyFrame

An instance method.

*/
SWIGINTERN VALUE
_wrap_NumericAnimationTrack_get_numeric_key_frame(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);
  {
    try {
      result = (Ogre::NumericKeyFrame *)((Ogre::NumericAnimationTrack const *)arg1)->getNumericKeyFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NumericKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NumericAnimationTrack._clone

  call-seq:
    _clone(Animation newParent) -> NumericAnimationTrack

An instance method.

*/
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);
  {
    try {
      result = (Ogre::NumericAnimationTrack *)((Ogre::NumericAnimationTrack const *)arg1)->_clone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NumericAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_NumericAnimationTrack(Ogre::NumericAnimationTrack *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::NodeAnimationTrack < Ogre::Ogre::AnimationTrack

  Proxy of C++ Ogre::NodeAnimationTrack class


*/
swig_class SwigClassNodeAnimationTrack;


/*
  Document-method: Ogre::NodeAnimationTrack.new

  call-seq:
    NodeAnimationTrack.new(Animation parent, unsigned short handle)
    NodeAnimationTrack.new(Animation parent, unsigned short handle, Node targetNode)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::NodeAnimationTrack *)new Ogre::NodeAnimationTrack(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::NodeAnimationTrack *)new Ogre::NodeAnimationTrack(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::NodeAnimationTrack.create_node_key_frame

  call-seq:
    create_node_key_frame(Real timePos) -> TransformKeyFrame

An instance method.

*/
SWIGINTERN VALUE
_wrap_NodeAnimationTrack_create_node_key_frame(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);
  {
    try {
      result = (Ogre::TransformKeyFrame *)(arg1)->createNodeKeyFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TransformKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NodeAnimationTrack.get_associated_node

  call-seq:
    get_associated_node -> Node

An instance method.

*/
SWIGINTERN VALUE
_wrap_NodeAnimationTrack_get_associated_node(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);
  {
    try {
      result = (Ogre::Node *)((Ogre::NodeAnimationTrack const *)arg1)->getAssociatedNode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NodeAnimationTrack.set_associated_node

  call-seq:
    set_associated_node(Node node)

An instance method.

*/
SWIGINTERN VALUE
_wrap_NodeAnimationTrack_set_associated_node(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);
  {
    try {
      (arg1)->setAssociatedNode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NodeAnimationTrack.apply_to_node

  call-seq:
    apply_to_node(Node node, TimeIndex timeIndex, Real weight=1.0, Real scale=1.0)
    apply_to_node(Node node, TimeIndex timeIndex, Real weight=1.0)
    apply_to_node(Node node, TimeIndex timeIndex)

An instance method.

*/
SWIGINTERN VALUE
_wrap_NodeAnimationTrack_apply_to_node__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);
  {
    try {
      (arg1)->applyToNode(arg2,(Ogre::TimeIndex const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_apply_to_node__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);
  {
    try {
      (arg1)->applyToNode(arg2,(Ogre::TimeIndex const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_apply_to_node__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);
  {
    try {
      (arg1)->applyToNode(arg2,(Ogre::TimeIndex const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_NodeAnimationTrack_apply_to_node(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_apply_to_node__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_apply_to_node__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_apply_to_node__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "NodeAnimationTrack.apply_to_node", 
    "    void NodeAnimationTrack.apply_to_node(Ogre::Node *node, Ogre::TimeIndex const &timeIndex, Ogre::Real weight, Ogre::Real scale)\n"
    "    void NodeAnimationTrack.apply_to_node(Ogre::Node *node, Ogre::TimeIndex const &timeIndex, Ogre::Real weight)\n"
    "    void NodeAnimationTrack.apply_to_node(Ogre::Node *node, Ogre::TimeIndex const &timeIndex)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::NodeAnimationTrack.set_use_shortest_rotation_path

  call-seq:
    set_use_shortest_rotation_path(bool useShortestPath)

An instance method.

*/
SWIGINTERN VALUE
_wrap_NodeAnimationTrack_set_use_shortest_rotation_path(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);
  {
    try {
      (arg1)->setUseShortestRotationPath(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NodeAnimationTrack.get_use_shortest_rotation_path

  call-seq:
    get_use_shortest_rotation_path -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_NodeAnimationTrack_get_use_shortest_rotation_path(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);
  {
    try {
      result = (bool)((Ogre::NodeAnimationTrack const *)arg1)->getUseShortestRotationPath();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NodeAnimationTrack.get_interpolated_key_frame

  call-seq:
    get_interpolated_key_frame(TimeIndex timeIndex, KeyFrame kf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_NodeAnimationTrack_get_interpolated_key_frame(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);
  {
    try {
      ((Ogre::NodeAnimationTrack const *)arg1)->getInterpolatedKeyFrame((Ogre::TimeIndex const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NodeAnimationTrack.apply

  call-seq:
    apply(TimeIndex timeIndex, Real weight=1.0, Real scale=1.0)
    apply(TimeIndex timeIndex, Real weight=1.0)
    apply(TimeIndex timeIndex)

An instance method.

*/
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);
  {
    try {
      (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply((Ogre::TimeIndex const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::NodeAnimationTrack._key_frame_data_changed

  call-seq:
    _key_frame_data_changed

An instance method.

*/
SWIGINTERN VALUE
_wrap_NodeAnimationTrack__key_frame_data_changed(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);
  {
    try {
      ((Ogre::NodeAnimationTrack const *)arg1)->_keyFrameDataChanged();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NodeAnimationTrack.get_node_key_frame

  call-seq:
    get_node_key_frame(unsigned short index) -> TransformKeyFrame

An instance method.

*/
SWIGINTERN VALUE
_wrap_NodeAnimationTrack_get_node_key_frame(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);
  {
    try {
      result = (Ogre::TransformKeyFrame *)((Ogre::NodeAnimationTrack const *)arg1)->getNodeKeyFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TransformKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NodeAnimationTrack.has_non_zero_key_frames

  call-seq:
    has_non_zero_key_frames -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_NodeAnimationTrack_has_non_zero_key_frames(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);
  {
    try {
      result = (bool)((Ogre::NodeAnimationTrack const *)arg1)->hasNonZeroKeyFrames();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NodeAnimationTrack.optimise

  call-seq:
    optimise

An instance method.

*/
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);
  {
    try {
      (arg1)->optimise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NodeAnimationTrack._clone

  call-seq:
    _clone(Animation newParent) -> NodeAnimationTrack

An instance method.

*/
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);
  {
    try {
      result = (Ogre::NodeAnimationTrack *)((Ogre::NodeAnimationTrack const *)arg1)->_clone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NodeAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NodeAnimationTrack._apply_base_key_frame

  call-seq:
    _apply_base_key_frame(KeyFrame base)

An instance method.

*/
SWIGINTERN VALUE
_wrap_NodeAnimationTrack__apply_base_key_frame(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);
  {
    try {
      (arg1)->_applyBaseKeyFrame((Ogre::KeyFrame const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::VertexAnimationTrack < Ogre::Ogre::AnimationTrack

  Proxy of C++ Ogre::VertexAnimationTrack class


*/
swig_class SwigClassVertexAnimationTrack;


/*
  Document-method: Ogre::TargetMode.TM_SOFTWARE

  call-seq:
    TM_SOFTWARE -> int

A class method.

*/

/*
  Document-method: Ogre::TargetMode.TM_HARDWARE

  call-seq:
    TM_HARDWARE -> int

A class method.

*/

/*
  Document-method: Ogre::VertexAnimationTrack.new

  call-seq:
    VertexAnimationTrack.new(Animation parent, unsigned short handle, VertexAnimationType animType)
    VertexAnimationTrack.new(Animation parent, unsigned short handle, VertexAnimationType animType, 
    VertexData targetData, TargetMode target=TM_SOFTWARE)
    VertexAnimationTrack.new(Animation parent, unsigned short handle, VertexAnimationType animType, 
    VertexData targetData)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::VertexAnimationTrack *)new Ogre::VertexAnimationTrack(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::VertexAnimationTrack *)new Ogre::VertexAnimationTrack(arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::VertexAnimationTrack *)new Ogre::VertexAnimationTrack(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::VertexAnimationTrack.get_animation_type

  call-seq:
    get_animation_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_get_animation_type(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);
  {
    try {
      result = (Ogre::VertexAnimationType)((Ogre::VertexAnimationTrack const *)arg1)->getAnimationType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.get_vertex_animation_includes_normals

  call-seq:
    get_vertex_animation_includes_normals -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_get_vertex_animation_includes_normals(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);
  {
    try {
      result = (bool)((Ogre::VertexAnimationTrack const *)arg1)->getVertexAnimationIncludesNormals();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.create_vertex_morph_key_frame

  call-seq:
    create_vertex_morph_key_frame(Real timePos) -> VertexMorphKeyFrame

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_create_vertex_morph_key_frame(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);
  {
    try {
      result = (Ogre::VertexMorphKeyFrame *)(arg1)->createVertexMorphKeyFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexMorphKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.create_vertex_pose_key_frame

  call-seq:
    create_vertex_pose_key_frame(Real timePos) -> VertexPoseKeyFrame

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_create_vertex_pose_key_frame(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);
  {
    try {
      result = (Ogre::VertexPoseKeyFrame *)(arg1)->createVertexPoseKeyFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexPoseKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.get_interpolated_key_frame

  call-seq:
    get_interpolated_key_frame(TimeIndex timeIndex, KeyFrame kf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_get_interpolated_key_frame(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);
  {
    try {
      ((Ogre::VertexAnimationTrack const *)arg1)->getInterpolatedKeyFrame((Ogre::TimeIndex const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.apply

  call-seq:
    apply(TimeIndex timeIndex, Real weight=1.0, Real scale=1.0)
    apply(TimeIndex timeIndex, Real weight=1.0)
    apply(TimeIndex timeIndex)

An instance method.

*/
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);
  {
    try {
      (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply((Ogre::TimeIndex const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::VertexAnimationTrack.apply_to_vertex_data

  call-seq:
    apply_to_vertex_data(VertexData data, TimeIndex timeIndex, Real weight=1.0, 
    PoseList poseList=0)
    apply_to_vertex_data(VertexData data, TimeIndex timeIndex, Real weight=1.0)
    apply_to_vertex_data(VertexData data, TimeIndex timeIndex)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_apply_to_vertex_data__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);
  {
    try {
      (arg1)->applyToVertexData(arg2,(Ogre::TimeIndex const &)*arg3,arg4,(Ogre::PoseList const *)arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_apply_to_vertex_data__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);
  {
    try {
      (arg1)->applyToVertexData(arg2,(Ogre::TimeIndex const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_apply_to_vertex_data__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);
  {
    try {
      (arg1)->applyToVertexData(arg2,(Ogre::TimeIndex const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexAnimationTrack_apply_to_vertex_data(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_apply_to_vertex_data__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_apply_to_vertex_data__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_apply_to_vertex_data__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "VertexAnimationTrack.apply_to_vertex_data", 
    "    void VertexAnimationTrack.apply_to_vertex_data(Ogre::VertexData *data, Ogre::TimeIndex const &timeIndex, Ogre::Real weight, Ogre::PoseList const *poseList)\n"
    "    void VertexAnimationTrack.apply_to_vertex_data(Ogre::VertexData *data, Ogre::TimeIndex const &timeIndex, Ogre::Real weight)\n"
    "    void VertexAnimationTrack.apply_to_vertex_data(Ogre::VertexData *data, Ogre::TimeIndex const &timeIndex)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.get_vertex_morph_key_frame

  call-seq:
    get_vertex_morph_key_frame(unsigned short index) -> VertexMorphKeyFrame

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_get_vertex_morph_key_frame(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);
  {
    try {
      result = (Ogre::VertexMorphKeyFrame *)((Ogre::VertexAnimationTrack const *)arg1)->getVertexMorphKeyFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexMorphKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.get_vertex_pose_key_frame

  call-seq:
    get_vertex_pose_key_frame(unsigned short index) -> VertexPoseKeyFrame

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_get_vertex_pose_key_frame(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);
  {
    try {
      result = (Ogre::VertexPoseKeyFrame *)((Ogre::VertexAnimationTrack const *)arg1)->getVertexPoseKeyFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexPoseKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.set_associated_vertex_data

  call-seq:
    set_associated_vertex_data(VertexData data)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_set_associated_vertex_data(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);
  {
    try {
      (arg1)->setAssociatedVertexData(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.get_associated_vertex_data

  call-seq:
    get_associated_vertex_data -> VertexData

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_get_associated_vertex_data(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);
  {
    try {
      result = (Ogre::VertexData *)((Ogre::VertexAnimationTrack const *)arg1)->getAssociatedVertexData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.set_target_mode

  call-seq:
    set_target_mode(TargetMode m)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_set_target_mode(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);
  {
    try {
      (arg1)->setTargetMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.get_target_mode

  call-seq:
    get_target_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_get_target_mode(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);
  {
    try {
      result = (Ogre::VertexAnimationTrack::TargetMode)((Ogre::VertexAnimationTrack const *)arg1)->getTargetMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.has_non_zero_key_frames

  call-seq:
    has_non_zero_key_frames -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack_has_non_zero_key_frames(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);
  {
    try {
      result = (bool)((Ogre::VertexAnimationTrack const *)arg1)->hasNonZeroKeyFrames();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack.optimise

  call-seq:
    optimise

An instance method.

*/
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);
  {
    try {
      (arg1)->optimise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack._clone

  call-seq:
    _clone(Animation newParent) -> VertexAnimationTrack

An instance method.

*/
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);
  {
    try {
      result = (Ogre::VertexAnimationTrack *)((Ogre::VertexAnimationTrack const *)arg1)->_clone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexAnimationTrack._apply_base_key_frame

  call-seq:
    _apply_base_key_frame(KeyFrame base)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexAnimationTrack__apply_base_key_frame(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);
  {
    try {
      (arg1)->_applyBaseKeyFrame((Ogre::KeyFrame const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexAnimationTrack(Ogre::VertexAnimationTrack *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::AnimationState

  Proxy of C++ Ogre::AnimationState class


*/
swig_class SwigClassAnimationState;


/*
  Document-method: Ogre::AnimationState.new

  call-seq:
    AnimationState.new(String animName, AnimationStateSet parent, Real timePos, 
    Real length, Real weight=1.0, bool enabled=false)
    AnimationState.new(String animName, AnimationStateSet parent, Real timePos, 
    Real length, Real weight=1.0)
    AnimationState.new(String animName, AnimationStateSet parent, Real timePos, 
    Real length)
    AnimationState.new(AnimationStateSet parent, AnimationState rhs)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::AnimationState *)new Ogre::AnimationState((Ogre::String const &)*arg1,arg2,arg3,arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::AnimationState *)new Ogre::AnimationState((Ogre::String const &)*arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::AnimationState *)new Ogre::AnimationState((Ogre::String const &)*arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::AnimationState *)new Ogre::AnimationState(arg1,(Ogre::AnimationState const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::AnimationState.get_animation_name

  call-seq:
    get_animation_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_get_animation_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::AnimationState const *)arg1)->getAnimationName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.get_time_position

  call-seq:
    get_time_position -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_get_time_position(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AnimationState const *)arg1)->getTimePosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.set_time_position

  call-seq:
    set_time_position(Real timePos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_set_time_position(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);
  {
    try {
      (arg1)->setTimePosition(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.get_length

  call-seq:
    get_length -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_get_length(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AnimationState const *)arg1)->getLength();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.set_length

  call-seq:
    set_length(Real len)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_set_length(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);
  {
    try {
      (arg1)->setLength(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.get_weight

  call-seq:
    get_weight -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_get_weight(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AnimationState const *)arg1)->getWeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.set_weight

  call-seq:
    set_weight(Real weight)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_set_weight(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);
  {
    try {
      (arg1)->setWeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.add_time

  call-seq:
    add_time(Real offset)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_add_time(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);
  {
    try {
      (arg1)->addTime(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.has_ended

  call-seq:
    has_ended -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_has_ended(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);
  {
    try {
      result = (bool)((Ogre::AnimationState const *)arg1)->hasEnded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.get_enabled

  call-seq:
    get_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_get_enabled(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);
  {
    try {
      result = (bool)((Ogre::AnimationState const *)arg1)->getEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.set_enabled

  call-seq:
    set_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_set_enabled(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);
  {
    try {
      (arg1)->setEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::AnimationState const *)arg1)->operator ==((Ogre::AnimationState const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.set_loop

  call-seq:
    set_loop(bool loop)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_set_loop(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);
  {
    try {
      (arg1)->setLoop(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.get_loop

  call-seq:
    get_loop -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_get_loop(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);
  {
    try {
      result = (bool)((Ogre::AnimationState const *)arg1)->getLoop();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.copy_state_from

  call-seq:
    copy_state_from(AnimationState animState)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_copy_state_from(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);
  {
    try {
      (arg1)->copyStateFrom((Ogre::AnimationState const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.get_parent

  call-seq:
    get_parent -> AnimationStateSet

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_get_parent(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);
  {
    try {
      result = (Ogre::AnimationStateSet *)((Ogre::AnimationState const *)arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.create_blend_mask

  call-seq:
    create_blend_mask(size_t blendMaskSizeHint, float initialWeight=1.0)
    create_blend_mask(size_t blendMaskSizeHint)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_create_blend_mask__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);
  {
    try {
      (arg1)->createBlendMask(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_create_blend_mask__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);
  {
    try {
      (arg1)->createBlendMask(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimationState_create_blend_mask(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_create_blend_mask__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_create_blend_mask__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "AnimationState.create_blend_mask", 
    "    void AnimationState.create_blend_mask(size_t blendMaskSizeHint, float initialWeight)\n"
    "    void AnimationState.create_blend_mask(size_t blendMaskSizeHint)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.destroy_blend_mask

  call-seq:
    destroy_blend_mask

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_destroy_blend_mask(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);
  {
    try {
      (arg1)->destroyBlendMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState._set_blend_mask_data

  call-seq:
    _set_blend_mask_data(float blendMaskData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState__set_blend_mask_data(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);
  {
    try {
      (arg1)->_setBlendMaskData((float const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState._set_blend_mask

  call-seq:
    _set_blend_mask(BoneBlendMask blendMask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState__set_blend_mask(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);
  {
    try {
      (arg1)->_setBlendMask((Ogre::AnimationState::BoneBlendMask const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.get_blend_mask

  call-seq:
    get_blend_mask -> BoneBlendMask

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_get_blend_mask(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);
  {
    try {
      result = (Ogre::AnimationState::BoneBlendMask *)((Ogre::AnimationState const *)arg1)->getBlendMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.has_blend_mask

  call-seq:
    has_blend_mask -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_has_blend_mask(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);
  {
    try {
      result = (bool)((Ogre::AnimationState const *)arg1)->hasBlendMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.set_blend_mask_entry

  call-seq:
    set_blend_mask_entry(size_t boneHandle, float weight)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_set_blend_mask_entry(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);
  {
    try {
      (arg1)->setBlendMaskEntry(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.get_blend_mask_entry

  call-seq:
    get_blend_mask_entry(size_t boneHandle) -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationState_get_blend_mask_entry(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);
  {
    try {
      result = (float)((Ogre::AnimationState const *)arg1)->getBlendMaskEntry(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::AnimationStateSet

  Proxy of C++ Ogre::AnimationStateSet class


*/
swig_class SwigClassAnimationStateSet;


/*
  Document-method: Ogre::AnimationStateSet.new

  call-seq:
    AnimationStateSet.new
    AnimationStateSet.new(AnimationStateSet rhs)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::AnimationStateSet *)new Ogre::AnimationStateSet();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::AnimationStateSet *)new Ogre::AnimationStateSet((Ogre::AnimationStateSet const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::AnimationStateSet.create_animation_state

  call-seq:
    create_animation_state(String animName, Real timePos, Real length, Real weight=1.0, 
    bool enabled=false) -> AnimationState
    create_animation_state(String animName, Real timePos, Real length, Real weight=1.0) -> AnimationState
    create_animation_state(String animName, Real timePos, Real length) -> AnimationState

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet_create_animation_state__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);
  {
    try {
      result = (Ogre::AnimationState *)(arg1)->createAnimationState((Ogre::String const &)*arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_create_animation_state__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);
  {
    try {
      result = (Ogre::AnimationState *)(arg1)->createAnimationState((Ogre::String const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_animation_state__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);
  {
    try {
      result = (Ogre::AnimationState *)(arg1)->createAnimationState((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_animation_state(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_create_animation_state__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_create_animation_state__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_create_animation_state__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "AnimationStateSet.create_animation_state", 
    "    Ogre::AnimationState * AnimationStateSet.create_animation_state(Ogre::String const &animName, Ogre::Real timePos, Ogre::Real length, Ogre::Real weight, bool enabled)\n"
    "    Ogre::AnimationState * AnimationStateSet.create_animation_state(Ogre::String const &animName, Ogre::Real timePos, Ogre::Real length, Ogre::Real weight)\n"
    "    Ogre::AnimationState * AnimationStateSet.create_animation_state(Ogre::String const &animName, Ogre::Real timePos, Ogre::Real length)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateSet.get_animation_state

  call-seq:
    get_animation_state(String name) -> AnimationState

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet_get_animation_state(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;
  }
  {
    try {
      result = (Ogre::AnimationState *)((Ogre::AnimationStateSet const *)arg1)->getAnimationState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateSet.has_animation_state

  call-seq:
    has_animation_state(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet_has_animation_state(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;
  }
  {
    try {
      result = (bool)((Ogre::AnimationStateSet const *)arg1)->hasAnimationState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateSet.remove_animation_state

  call-seq:
    remove_animation_state(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet_remove_animation_state(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;
  }
  {
    try {
      (arg1)->removeAnimationState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateSet.remove_all_animation_states

  call-seq:
    remove_all_animation_states

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet_remove_all_animation_states(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);
  {
    try {
      (arg1)->removeAllAnimationStates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateSet.get_animation_state_iterator

  call-seq:
    get_animation_state_iterator -> AnimationStateIterator
    get_animation_state_iterator -> ConstAnimationStateIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet_get_animation_state_iterator__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);
  {
    try {
      result = (arg1)->getAnimationStateIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::AnimationStateIterator(static_cast< const Ogre::AnimationStateIterator& >(result))), SWIGTYPE_p_Ogre__AnimationStateIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_get_animation_state_iterator__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);
  {
    try {
      result = ((Ogre::AnimationStateSet const *)arg1)->getAnimationStateIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ConstAnimationStateIterator(static_cast< const Ogre::ConstAnimationStateIterator& >(result))), SWIGTYPE_p_Ogre__ConstAnimationStateIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimationStateSet_get_animation_state_iterator(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_get_animation_state_iterator__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_get_animation_state_iterator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "AnimationStateSet.get_animation_state_iterator", 
    "    Ogre::ConstAnimationStateIterator AnimationStateSet.get_animation_state_iterator()\n"
    "    Ogre::ConstAnimationStateIterator AnimationStateSet.get_animation_state_iterator()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateSet.copy_matching_state

  call-seq:
    copy_matching_state(AnimationStateSet target)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet_copy_matching_state(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);
  {
    try {
      ((Ogre::AnimationStateSet const *)arg1)->copyMatchingState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateSet._notify_dirty

  call-seq:
    _notify_dirty

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet__notify_dirty(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);
  {
    try {
      (arg1)->_notifyDirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateSet.get_dirty_frame_number

  call-seq:
    get_dirty_frame_number -> unsigned long

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet_get_dirty_frame_number(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);
  {
    try {
      result = (unsigned long)((Ogre::AnimationStateSet const *)arg1)->getDirtyFrameNumber();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateSet._notify_animation_state_enabled

  call-seq:
    _notify_animation_state_enabled(AnimationState target, bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet__notify_animation_state_enabled(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);
  {
    try {
      (arg1)->_notifyAnimationStateEnabled(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateSet.has_enabled_animation_state

  call-seq:
    has_enabled_animation_state -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet_has_enabled_animation_state(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);
  {
    try {
      result = (bool)((Ogre::AnimationStateSet const *)arg1)->hasEnabledAnimationState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateSet.get_enabled_animation_state_iterator

  call-seq:
    get_enabled_animation_state_iterator -> ConstEnabledAnimationStateIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet_get_enabled_animation_state_iterator(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);
  {
    try {
      result = ((Ogre::AnimationStateSet const *)arg1)->getEnabledAnimationStateIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ConstEnabledAnimationStateIterator(static_cast< const Ogre::ConstEnabledAnimationStateIterator& >(result))), SWIGTYPE_p_Ogre__ConstEnabledAnimationStateIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateSet.each_animation_state

  call-seq:
    each_animation_state

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateSet_each_animation_state(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);
  {
    try {
      Ogre_AnimationStateSet_each_AnimationState(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::AnimationStateControllerValue

  Proxy of C++ Ogre::AnimationStateControllerValue class


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


/*
  Document-method: Ogre::AnimationStateControllerValue.new

  call-seq:
    AnimationStateControllerValue.new(AnimationState targetAnimationState)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::AnimationStateControllerValue *)new Ogre::AnimationStateControllerValue(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AnimationStateControllerValue(Ogre::AnimationStateControllerValue *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::AnimationStateControllerValue.get_value

  call-seq:
    get_value -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateControllerValue_get_value(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AnimationStateControllerValue const *)arg1)->getValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationStateControllerValue.set_value

  call-seq:
    set_value(Real value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationStateControllerValue_set_value(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);
  {
    try {
      (arg1)->setValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::AnimationContainer

  Proxy of C++ Ogre::AnimationContainer class


*/
swig_class SwigClassAnimationContainer;


/*
  Document-method: Ogre::AnimationContainer.get_num_animations

  call-seq:
    get_num_animations -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationContainer_get_num_animations(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);
  {
    try {
      result = (unsigned short)((Ogre::AnimationContainer const *)arg1)->getNumAnimations();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationContainer.get_animation

  call-seq:
    get_animation(unsigned short index) -> Animation
    get_animation(String name) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationContainer_get_animation__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);
  {
    try {
      result = (Ogre::Animation *)((Ogre::AnimationContainer const *)arg1)->getAnimation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationContainer_get_animation__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;
  }
  {
    try {
      result = (Ogre::Animation *)((Ogre::AnimationContainer const *)arg1)->getAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_animation(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_get_animation__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_get_animation__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "AnimationContainer.get_animation", 
    "    Ogre::Animation * AnimationContainer.get_animation(unsigned short index)\n"
    "    Ogre::Animation * AnimationContainer.get_animation(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AnimationContainer.create_animation

  call-seq:
    create_animation(String name, Real length) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationContainer_create_animation(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);
  {
    try {
      result = (Ogre::Animation *)(arg1)->createAnimation((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::AnimationContainer.has_animation

  call-seq:
    has_animation(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationContainer_has_animation(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;
  }
  {
    try {
      result = (bool)((Ogre::AnimationContainer const *)arg1)->hasAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::AnimationContainer.remove_animation

  call-seq:
    remove_animation(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationContainer_remove_animation(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;
  }
  {
    try {
      (arg1)->removeAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_Ogre_AnimationContainer(Ogre::AnimationContainer *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::Animation

  Proxy of C++ Ogre::Animation class


*/
swig_class SwigClassAnimation;


/*
  Document-method: Ogre::InterpolationMode.IM_LINEAR

  call-seq:
    IM_LINEAR -> int

A class method.

*/

/*
  Document-method: Ogre::InterpolationMode.IM_SPLINE

  call-seq:
    IM_SPLINE -> int

A class method.

*/

/*
  Document-method: Ogre::RotationInterpolationMode.RIM_LINEAR

  call-seq:
    RIM_LINEAR -> int

A class method.

*/

/*
  Document-method: Ogre::RotationInterpolationMode.RIM_SPHERICAL

  call-seq:
    RIM_SPHERICAL -> int

A class method.

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


/*
  Document-method: Ogre::Animation.new

  call-seq:
    Animation.new(String name, Real length)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Animation *)new Ogre::Animation((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::Animation.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Animation const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_length

  call-seq:
    get_length -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_length(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Animation const *)arg1)->getLength();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.set_length

  call-seq:
    set_length(Real len)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_set_length(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);
  {
    try {
      (arg1)->setLength(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.create_node_track

  call-seq:
    create_node_track(unsigned short handle) -> NodeAnimationTrack
    create_node_track(unsigned short handle, Node node) -> NodeAnimationTrack

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_create_node_track__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);
  {
    try {
      result = (Ogre::NodeAnimationTrack *)(arg1)->createNodeTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NodeAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.create_numeric_track

  call-seq:
    create_numeric_track(unsigned short handle) -> NumericAnimationTrack
    create_numeric_track(unsigned short handle, AnimableValuePtr anim) -> NumericAnimationTrack

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_create_numeric_track__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);
  {
    try {
      result = (Ogre::NumericAnimationTrack *)(arg1)->createNumericTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NumericAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.create_vertex_track

  call-seq:
    create_vertex_track(unsigned short handle, VertexAnimationType animType) -> VertexAnimationTrack
    create_vertex_track(unsigned short handle, VertexData data, VertexAnimationType animType) -> VertexAnimationTrack

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_create_vertex_track__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);
  {
    try {
      result = (Ogre::VertexAnimationTrack *)(arg1)->createVertexTrack(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.create_node_track

  call-seq:
    create_node_track(unsigned short handle) -> NodeAnimationTrack
    create_node_track(unsigned short handle, Node node) -> NodeAnimationTrack

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_create_node_track__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);
  {
    try {
      result = (Ogre::NodeAnimationTrack *)(arg1)->createNodeTrack(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NodeAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_create_node_track(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_create_node_track__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_create_node_track__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Animation.create_node_track", 
    "    Ogre::NodeAnimationTrack * Animation.create_node_track(unsigned short handle)\n"
    "    Ogre::NodeAnimationTrack * Animation.create_node_track(unsigned short handle, Ogre::Node *node)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Animation.create_numeric_track

  call-seq:
    create_numeric_track(unsigned short handle) -> NumericAnimationTrack
    create_numeric_track(unsigned short handle, AnimableValuePtr anim) -> NumericAnimationTrack

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_create_numeric_track__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);
  {
    try {
      result = (Ogre::NumericAnimationTrack *)(arg1)->createNumericTrack(arg2,(Ogre::AnimableValuePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NumericAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_create_numeric_track(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_create_numeric_track__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_create_numeric_track__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Animation.create_numeric_track", 
    "    Ogre::NumericAnimationTrack * Animation.create_numeric_track(unsigned short handle)\n"
    "    Ogre::NumericAnimationTrack * Animation.create_numeric_track(unsigned short handle, Ogre::AnimableValuePtr const &anim)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Animation.create_vertex_track

  call-seq:
    create_vertex_track(unsigned short handle, VertexAnimationType animType) -> VertexAnimationTrack
    create_vertex_track(unsigned short handle, VertexData data, VertexAnimationType animType) -> VertexAnimationTrack

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_create_vertex_track__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);
  {
    try {
      result = (Ogre::VertexAnimationTrack *)(arg1)->createVertexTrack(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_create_vertex_track(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_create_vertex_track__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_create_vertex_track__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Animation.create_vertex_track", 
    "    Ogre::VertexAnimationTrack * Animation.create_vertex_track(unsigned short handle, Ogre::VertexAnimationType animType)\n"
    "    Ogre::VertexAnimationTrack * Animation.create_vertex_track(unsigned short handle, Ogre::VertexData *data, Ogre::VertexAnimationType animType)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_num_node_tracks

  call-seq:
    get_num_node_tracks -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_num_node_tracks(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);
  {
    try {
      result = (unsigned short)((Ogre::Animation const *)arg1)->getNumNodeTracks();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_node_track

  call-seq:
    get_node_track(unsigned short handle) -> NodeAnimationTrack

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_node_track(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);
  {
    try {
      result = (Ogre::NodeAnimationTrack *)((Ogre::Animation const *)arg1)->getNodeTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NodeAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.has_node_track

  call-seq:
    has_node_track(unsigned short handle) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_has_node_track(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);
  {
    try {
      result = (bool)((Ogre::Animation const *)arg1)->hasNodeTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_num_numeric_tracks

  call-seq:
    get_num_numeric_tracks -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_num_numeric_tracks(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);
  {
    try {
      result = (unsigned short)((Ogre::Animation const *)arg1)->getNumNumericTracks();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_numeric_track

  call-seq:
    get_numeric_track(unsigned short handle) -> NumericAnimationTrack

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_numeric_track(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);
  {
    try {
      result = (Ogre::NumericAnimationTrack *)((Ogre::Animation const *)arg1)->getNumericTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NumericAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.has_numeric_track

  call-seq:
    has_numeric_track(unsigned short handle) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_has_numeric_track(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);
  {
    try {
      result = (bool)((Ogre::Animation const *)arg1)->hasNumericTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_num_vertex_tracks

  call-seq:
    get_num_vertex_tracks -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_num_vertex_tracks(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);
  {
    try {
      result = (unsigned short)((Ogre::Animation const *)arg1)->getNumVertexTracks();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_vertex_track

  call-seq:
    get_vertex_track(unsigned short handle) -> VertexAnimationTrack

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_vertex_track(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);
  {
    try {
      result = (Ogre::VertexAnimationTrack *)((Ogre::Animation const *)arg1)->getVertexTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.has_vertex_track

  call-seq:
    has_vertex_track(unsigned short handle) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_has_vertex_track(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);
  {
    try {
      result = (bool)((Ogre::Animation const *)arg1)->hasVertexTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.destroy_node_track

  call-seq:
    destroy_node_track(unsigned short handle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_destroy_node_track(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);
  {
    try {
      (arg1)->destroyNodeTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.destroy_numeric_track

  call-seq:
    destroy_numeric_track(unsigned short handle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_destroy_numeric_track(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);
  {
    try {
      (arg1)->destroyNumericTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.destroy_vertex_track

  call-seq:
    destroy_vertex_track(unsigned short handle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_destroy_vertex_track(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);
  {
    try {
      (arg1)->destroyVertexTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.destroy_all_tracks

  call-seq:
    destroy_all_tracks

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_destroy_all_tracks(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);
  {
    try {
      (arg1)->destroyAllTracks();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.destroy_all_node_tracks

  call-seq:
    destroy_all_node_tracks

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_destroy_all_node_tracks(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);
  {
    try {
      (arg1)->destroyAllNodeTracks();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.destroy_all_numeric_tracks

  call-seq:
    destroy_all_numeric_tracks

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_destroy_all_numeric_tracks(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);
  {
    try {
      (arg1)->destroyAllNumericTracks();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.destroy_all_vertex_tracks

  call-seq:
    destroy_all_vertex_tracks

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_destroy_all_vertex_tracks(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);
  {
    try {
      (arg1)->destroyAllVertexTracks();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.apply

  call-seq:
    apply(Real timePos, Real weight=1.0, Real scale=1.0)
    apply(Real timePos, Real weight=1.0)
    apply(Real timePos)
    apply(Skeleton skeleton, Real timePos, Real weight=1.0, Real scale=1.0)
    apply(Skeleton skeleton, Real timePos, Real weight=1.0)
    apply(Skeleton skeleton, Real timePos)
    apply(Skeleton skeleton, Real timePos, float weight, BoneBlendMask blendMask, 
    Real scale)
    apply(Entity entity, Real timePos, Real weight, bool software, 
    bool hardware)

An instance method.

*/
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);
  {
    try {
      (arg1)->apply(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.apply_to_node

  call-seq:
    apply_to_node(Node node, Real timePos, Real weight=1.0, Real scale=1.0)
    apply_to_node(Node node, Real timePos, Real weight=1.0)
    apply_to_node(Node node, Real timePos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_apply_to_node__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);
  {
    try {
      (arg1)->applyToNode(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply_to_node__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);
  {
    try {
      (arg1)->applyToNode(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply_to_node__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);
  {
    try {
      (arg1)->applyToNode(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_apply_to_node(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_apply_to_node__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_apply_to_node__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_apply_to_node__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Animation.apply_to_node", 
    "    void Animation.apply_to_node(Ogre::Node *node, Ogre::Real timePos, Ogre::Real weight, Ogre::Real scale)\n"
    "    void Animation.apply_to_node(Ogre::Node *node, Ogre::Real timePos, Ogre::Real weight)\n"
    "    void Animation.apply_to_node(Ogre::Node *node, Ogre::Real timePos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Animation.apply

  call-seq:
    apply(Real timePos, Real weight=1.0, Real scale=1.0)
    apply(Real timePos, Real weight=1.0)
    apply(Real timePos)
    apply(Skeleton skeleton, Real timePos, Real weight=1.0, Real scale=1.0)
    apply(Skeleton skeleton, Real timePos, Real weight=1.0)
    apply(Skeleton skeleton, Real timePos)
    apply(Skeleton skeleton, Real timePos, float weight, BoneBlendMask blendMask, 
    Real scale)
    apply(Entity entity, Real timePos, Real weight, bool software, 
    bool hardware)

An instance method.

*/
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);
  {
    try {
      (arg1)->apply(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->apply(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply(arg2,arg3,arg4,(Ogre::AnimationState::BoneBlendMask const *)arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->apply(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Animation.apply_to_animable

  call-seq:
    apply_to_animable(AnimableValuePtr anim, Real timePos, Real weight=1.0, 
    Real scale=1.0)
    apply_to_animable(AnimableValuePtr anim, Real timePos, Real weight=1.0)
    apply_to_animable(AnimableValuePtr anim, Real timePos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_apply_to_animable__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);
  {
    try {
      (arg1)->applyToAnimable((Ogre::AnimableValuePtr const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply_to_animable__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);
  {
    try {
      (arg1)->applyToAnimable((Ogre::AnimableValuePtr const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply_to_animable__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);
  {
    try {
      (arg1)->applyToAnimable((Ogre::AnimableValuePtr const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_apply_to_animable(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_apply_to_animable__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_apply_to_animable__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_apply_to_animable__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Animation.apply_to_animable", 
    "    void Animation.apply_to_animable(Ogre::AnimableValuePtr const &anim, Ogre::Real timePos, Ogre::Real weight, Ogre::Real scale)\n"
    "    void Animation.apply_to_animable(Ogre::AnimableValuePtr const &anim, Ogre::Real timePos, Ogre::Real weight)\n"
    "    void Animation.apply_to_animable(Ogre::AnimableValuePtr const &anim, Ogre::Real timePos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Animation.apply_to_vertex_data

  call-seq:
    apply_to_vertex_data(VertexData data, Real timePos, Real weight=1.0)
    apply_to_vertex_data(VertexData data, Real timePos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_apply_to_vertex_data__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);
  {
    try {
      (arg1)->applyToVertexData(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply_to_vertex_data__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);
  {
    try {
      (arg1)->applyToVertexData(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_apply_to_vertex_data(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_apply_to_vertex_data__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_apply_to_vertex_data__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Animation.apply_to_vertex_data", 
    "    void Animation.apply_to_vertex_data(Ogre::VertexData *data, Ogre::Real timePos, Ogre::Real weight)\n"
    "    void Animation.apply_to_vertex_data(Ogre::VertexData *data, Ogre::Real timePos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Animation.set_interpolation_mode

  call-seq:
    set_interpolation_mode(InterpolationMode im)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_set_interpolation_mode(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);
  {
    try {
      (arg1)->setInterpolationMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_interpolation_mode

  call-seq:
    get_interpolation_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_interpolation_mode(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);
  {
    try {
      result = (Ogre::Animation::InterpolationMode)((Ogre::Animation const *)arg1)->getInterpolationMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.set_rotation_interpolation_mode

  call-seq:
    set_rotation_interpolation_mode(RotationInterpolationMode im)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_set_rotation_interpolation_mode(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);
  {
    try {
      (arg1)->setRotationInterpolationMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_rotation_interpolation_mode

  call-seq:
    get_rotation_interpolation_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_rotation_interpolation_mode(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);
  {
    try {
      result = (Ogre::Animation::RotationInterpolationMode)((Ogre::Animation const *)arg1)->getRotationInterpolationMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.set_default_interpolation_mode

  call-seq:
    set_default_interpolation_mode(InterpolationMode im)

A class method.

*/
SWIGINTERN VALUE
_wrap_Animation_set_default_interpolation_mode(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);
  {
    try {
      Ogre::Animation::setDefaultInterpolationMode(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_default_interpolation_mode

  call-seq:
    get_default_interpolation_mode -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_default_interpolation_mode(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;
  }
  {
    try {
      result = (Ogre::Animation::InterpolationMode)Ogre::Animation::getDefaultInterpolationMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.set_default_rotation_interpolation_mode

  call-seq:
    set_default_rotation_interpolation_mode(RotationInterpolationMode im)

A class method.

*/
SWIGINTERN VALUE
_wrap_Animation_set_default_rotation_interpolation_mode(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);
  {
    try {
      Ogre::Animation::setDefaultRotationInterpolationMode(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_default_rotation_interpolation_mode

  call-seq:
    get_default_rotation_interpolation_mode -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_default_rotation_interpolation_mode(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;
  }
  {
    try {
      result = (Ogre::Animation::RotationInterpolationMode)Ogre::Animation::getDefaultRotationInterpolationMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation._get_node_track_list

  call-seq:
    _get_node_track_list -> NodeTrackList

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation__get_node_track_list(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);
  {
    try {
      result = (Ogre::Animation::NodeTrackList *) &((Ogre::Animation const *)arg1)->_getNodeTrackList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::Animation.get_node_track_iterator

  call-seq:
    get_node_track_iterator -> NodeTrackIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_node_track_iterator(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);
  {
    try {
      result = ((Ogre::Animation const *)arg1)->getNodeTrackIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Animation._get_numeric_track_list

  call-seq:
    _get_numeric_track_list -> NumericTrackList

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation__get_numeric_track_list(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);
  {
    try {
      result = (Ogre::Animation::NumericTrackList *) &((Ogre::Animation const *)arg1)->_getNumericTrackList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::Animation.get_numeric_track_iterator

  call-seq:
    get_numeric_track_iterator -> NumericTrackIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_numeric_track_iterator(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);
  {
    try {
      result = ((Ogre::Animation const *)arg1)->getNumericTrackIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Animation._get_vertex_track_list

  call-seq:
    _get_vertex_track_list -> VertexTrackList

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation__get_vertex_track_list(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);
  {
    try {
      result = (Ogre::Animation::VertexTrackList *) &((Ogre::Animation const *)arg1)->_getVertexTrackList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::Animation.get_vertex_track_iterator

  call-seq:
    get_vertex_track_iterator -> VertexTrackIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_vertex_track_iterator(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);
  {
    try {
      result = ((Ogre::Animation const *)arg1)->getVertexTrackIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Animation.optimise

  call-seq:
    optimise(bool discardIdentityNodeTracks=true)
    optimise

An instance method.

*/
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);
  {
    try {
      (arg1)->optimise(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->optimise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Animation._collect_identity_node_tracks

  call-seq:
    _collect_identity_node_tracks(TrackHandleList tracks)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation__collect_identity_node_tracks(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);
  {
    try {
      ((Ogre::Animation const *)arg1)->_collectIdentityNodeTracks(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation._destroy_node_tracks

  call-seq:
    _destroy_node_tracks(TrackHandleList tracks)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation__destroy_node_tracks(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);
  {
    try {
      (arg1)->_destroyNodeTracks((Ogre::Animation::TrackHandleList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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;
  }
  {
    try {
      result = (Ogre::Animation *)((Ogre::Animation const *)arg1)->clone((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Animation._key_frame_list_changed

  call-seq:
    _key_frame_list_changed

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation__key_frame_list_changed(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);
  {
    try {
      (arg1)->_keyFrameListChanged();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation._get_time_index

  call-seq:
    _get_time_index(Real timePos) -> TimeIndex

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation__get_time_index(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);
  {
    try {
      result = ((Ogre::Animation const *)arg1)->_getTimeIndex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::TimeIndex(static_cast< const Ogre::TimeIndex& >(result))), SWIGTYPE_p_Ogre__TimeIndex, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.set_use_base_key_frame

  call-seq:
    set_use_base_key_frame(bool useBaseKeyFrame, Real keyframeTime=0.0, String baseAnimName=BLANK)
    set_use_base_key_frame(bool useBaseKeyFrame, Real keyframeTime=0.0)
    set_use_base_key_frame(bool useBaseKeyFrame)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_set_use_base_key_frame__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;
  }
  {
    try {
      (arg1)->setUseBaseKeyFrame(arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_set_use_base_key_frame__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);
  {
    try {
      (arg1)->setUseBaseKeyFrame(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_set_use_base_key_frame__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);
  {
    try {
      (arg1)->setUseBaseKeyFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_set_use_base_key_frame(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_set_use_base_key_frame__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_set_use_base_key_frame__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_set_use_base_key_frame__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Animation.set_use_base_key_frame", 
    "    void Animation.set_use_base_key_frame(bool useBaseKeyFrame, Ogre::Real keyframeTime, Ogre::String const &baseAnimName)\n"
    "    void Animation.set_use_base_key_frame(bool useBaseKeyFrame, Ogre::Real keyframeTime)\n"
    "    void Animation.set_use_base_key_frame(bool useBaseKeyFrame)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_use_base_key_frame

  call-seq:
    get_use_base_key_frame -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_use_base_key_frame(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);
  {
    try {
      result = (bool)((Ogre::Animation const *)arg1)->getUseBaseKeyFrame();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_base_key_frame_time

  call-seq:
    get_base_key_frame_time -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_base_key_frame_time(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Animation const *)arg1)->getBaseKeyFrameTime();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_base_key_frame_animation_name

  call-seq:
    get_base_key_frame_animation_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_base_key_frame_animation_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Animation const *)arg1)->getBaseKeyFrameAnimationName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation._apply_base_key_frame

  call-seq:
    _apply_base_key_frame

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation__apply_base_key_frame(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);
  {
    try {
      (arg1)->_applyBaseKeyFrame();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation._notify_container

  call-seq:
    _notify_container(AnimationContainer c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation__notify_container(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);
  {
    try {
      (arg1)->_notifyContainer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.get_container

  call-seq:
    get_container -> AnimationContainer

An instance method.

*/
SWIGINTERN VALUE
_wrap_Animation_get_container(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);
  {
    try {
      result = (Ogre::AnimationContainer *)(arg1)->getContainer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationContainer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DataStream

  Proxy of C++ Ogre::DataStream class


*/
swig_class SwigClassDataStream;


/*
  Document-method: Ogre::AccessMode.READ

  call-seq:
    READ -> int

A class method.

*/

/*
  Document-method: Ogre::AccessMode.WRITE

  call-seq:
    WRITE -> int

A class method.

*/

/*
  Document-method: Ogre::DataStream.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_DataStream_get_name(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);
  {
    try {
      result = (Ogre::String *) &(arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.get_access_mode

  call-seq:
    get_access_mode -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_DataStream_get_access_mode(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::DataStream const *)arg1)->getAccessMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.is_readable

  call-seq:
    is_readable -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_DataStream_is_readable(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);
  {
    try {
      result = (bool)((Ogre::DataStream const *)arg1)->isReadable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.is_writeable

  call-seq:
    is_writeable -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_DataStream_is_writeable(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);
  {
    try {
      result = (bool)((Ogre::DataStream const *)arg1)->isWriteable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DataStream(Ogre::DataStream *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DataStream.read

  call-seq:
    read(void buf, size_t count) -> size_t

An instance method.

*/
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);
  {
    try {
      result = (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.write

  call-seq:
    write(void buf, size_t count) -> size_t

An instance method.

*/
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);
  {
    try {
      result = (arg1)->write((void const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.read_line

  call-seq:
    read_line(char buf, size_t maxCount, String delim="\n") -> size_t
    read_line(char buf, size_t maxCount) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_DataStream_read_line__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;
  }
  {
    try {
      result = (arg1)->readLine(arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_read_line__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);
  {
    try {
      result = (arg1)->readLine(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_read_line(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_read_line__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_read_line__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "DataStream.read_line", 
    "    size_t DataStream.read_line(char *buf, size_t maxCount, Ogre::String const &delim)\n"
    "    size_t DataStream.read_line(char *buf, size_t maxCount)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.get_line

  call-seq:
    get_line(bool trimAfter=true) -> String
    get_line -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_DataStream_get_line__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);
  {
    try {
      result = (arg1)->getLine(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_get_line__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);
  {
    try {
      result = (arg1)->getLine();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DataStream_get_line(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_get_line__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_get_line__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "DataStream.get_line", 
    "    Ogre::String DataStream.get_line(bool trimAfter)\n"
    "    Ogre::String DataStream.get_line()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.get_as_string

  call-seq:
    get_as_string -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_DataStream_get_as_string(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);
  {
    try {
      result = (arg1)->getAsString();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.skip_line

  call-seq:
    skip_line(String delim="\n") -> size_t
    skip_line -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_DataStream_skip_line__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;
  }
  {
    try {
      result = (arg1)->skipLine((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_skip_line__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);
  {
    try {
      result = (arg1)->skipLine();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DataStream_skip_line(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_skip_line__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_skip_line__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "DataStream.skip_line", 
    "    size_t DataStream.skip_line(Ogre::String const &delim)\n"
    "    size_t DataStream.skip_line()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.skip

  call-seq:
    skip(long count)

An instance method.

*/
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);
  {
    try {
      (arg1)->skip(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.seek

  call-seq:
    seek(size_t pos)

An instance method.

*/
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);
  {
    try {
      (arg1)->seek(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.tell

  call-seq:
    tell -> size_t

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::DataStream const *)arg1)->tell();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.eof

  call-seq:
    eof -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::DataStream const *)arg1)->eof();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::DataStream const *)arg1)->size();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.close

  call-seq:
    close

An instance method.

*/
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);
  {
    try {
      (arg1)->close();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::MemoryDataStream < Ogre::Ogre::DataStream

  Proxy of C++ Ogre::MemoryDataStream class


*/
swig_class SwigClassMemoryDataStream;


/*
  Document-method: Ogre::MemoryDataStream.new

  call-seq:
    MemoryDataStream.new(void pMem, size_t size, bool freeOnClose=false, bool readOnly=false)
    MemoryDataStream.new(void pMem, size_t size, bool freeOnClose=false)
    MemoryDataStream.new(void pMem, size_t size)
    MemoryDataStream.new(String name, void pMem, size_t size, bool freeOnClose=false, 
    bool readOnly=false)
    MemoryDataStream.new(String name, void pMem, size_t size, bool freeOnClose=false)
    MemoryDataStream.new(String name, void pMem, size_t size)
    MemoryDataStream.new(DataStream sourceStream, bool freeOnClose=true, bool readOnly=false)
    MemoryDataStream.new(DataStream sourceStream, bool freeOnClose=true)
    MemoryDataStream.new(DataStream sourceStream)
    MemoryDataStream.new(DataStreamPtr sourceStream, bool freeOnClose=true, 
    bool readOnly=false)
    MemoryDataStream.new(DataStreamPtr sourceStream, bool freeOnClose=true)
    MemoryDataStream.new(DataStreamPtr sourceStream)
    MemoryDataStream.new(String name, DataStream sourceStream, bool freeOnClose=true, 
    bool readOnly=false)
    MemoryDataStream.new(String name, DataStream sourceStream, bool freeOnClose=true)
    MemoryDataStream.new(String name, DataStream sourceStream)
    MemoryDataStream.new(String name, DataStreamPtr sourceStream, bool freeOnClose=true, 
    bool readOnly=false)
    MemoryDataStream.new(String name, DataStreamPtr sourceStream, bool freeOnClose=true)
    MemoryDataStream.new(String name, DataStreamPtr sourceStream)
    MemoryDataStream.new(size_t size, bool freeOnClose=true, bool readOnly=false)
    MemoryDataStream.new(size_t size, bool freeOnClose=true)
    MemoryDataStream.new(size_t size)
    MemoryDataStream.new(String name, size_t size, bool freeOnClose=true, bool readOnly=false)
    MemoryDataStream.new(String name, size_t size, bool freeOnClose=true)
    MemoryDataStream.new(String name, size_t size)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,*arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,*arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,(Ogre::DataStreamPtr const &)*arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,(Ogre::DataStreamPtr const &)*arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,(Ogre::DataStreamPtr const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::MemoryDataStream.get_ptr

  call-seq:
    get_ptr -> uchar

An instance method.

*/
SWIGINTERN VALUE
_wrap_MemoryDataStream_get_ptr(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);
  {
    try {
      result = (Ogre::uchar *)(arg1)->getPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MemoryDataStream.get_current_ptr

  call-seq:
    get_current_ptr -> uchar

An instance method.

*/
SWIGINTERN VALUE
_wrap_MemoryDataStream_get_current_ptr(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);
  {
    try {
      result = (Ogre::uchar *)(arg1)->getCurrentPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MemoryDataStream.read

  call-seq:
    read(void buf, size_t count) -> size_t

An instance method.

*/
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);
  {
    try {
      result = (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MemoryDataStream.write

  call-seq:
    write(void buf, size_t count) -> size_t

An instance method.

*/
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);
  {
    try {
      result = (arg1)->write((void const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MemoryDataStream.read_line

  call-seq:
    read_line(char buf, size_t maxCount, String delim="\n") -> size_t
    read_line(char buf, size_t maxCount) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_MemoryDataStream_read_line__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;
  }
  {
    try {
      result = (arg1)->readLine(arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_read_line__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);
  {
    try {
      result = (arg1)->readLine(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_read_line(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_read_line__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_read_line__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MemoryDataStream.read_line", 
    "    size_t MemoryDataStream.read_line(char *buf, size_t maxCount, Ogre::String const &delim)\n"
    "    size_t MemoryDataStream.read_line(char *buf, size_t maxCount)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MemoryDataStream.skip_line

  call-seq:
    skip_line(String delim="\n") -> size_t
    skip_line -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_MemoryDataStream_skip_line__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;
  }
  {
    try {
      result = (arg1)->skipLine((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_skip_line__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);
  {
    try {
      result = (arg1)->skipLine();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MemoryDataStream_skip_line(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_skip_line__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_skip_line__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "MemoryDataStream.skip_line", 
    "    size_t MemoryDataStream.skip_line(Ogre::String const &delim)\n"
    "    size_t MemoryDataStream.skip_line()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MemoryDataStream.skip

  call-seq:
    skip(long count)

An instance method.

*/
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);
  {
    try {
      (arg1)->skip(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MemoryDataStream.seek

  call-seq:
    seek(size_t pos)

An instance method.

*/
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);
  {
    try {
      (arg1)->seek(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MemoryDataStream.tell

  call-seq:
    tell -> size_t

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::MemoryDataStream const *)arg1)->tell();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MemoryDataStream.eof

  call-seq:
    eof -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::MemoryDataStream const *)arg1)->eof();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MemoryDataStream.close

  call-seq:
    close

An instance method.

*/
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);
  {
    try {
      (arg1)->close();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MemoryDataStream.set_free_on_close

  call-seq:
    set_free_on_close(bool free)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MemoryDataStream_set_free_on_close(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);
  {
    try {
      (arg1)->setFreeOnClose(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::FileStreamDataStream < Ogre::Ogre::DataStream

  Proxy of C++ Ogre::FileStreamDataStream class


*/
swig_class SwigClassFileStreamDataStream;


/*
  Document-method: Ogre::FileStreamDataStream.new

  call-seq:
    FileStreamDataStream.new(std::ifstream s, bool freeOnClose=true)
    FileStreamDataStream.new(std::ifstream s)
    FileStreamDataStream.new(std::fstream s, bool freeOnClose=true)
    FileStreamDataStream.new(std::fstream s)
    FileStreamDataStream.new(String name, std::ifstream s, bool freeOnClose=true)
    FileStreamDataStream.new(String name, std::ifstream s)
    FileStreamDataStream.new(String name, std::fstream s, bool freeOnClose=true)
    FileStreamDataStream.new(String name, std::fstream s)
    FileStreamDataStream.new(String name, std::ifstream s, size_t size, bool freeOnClose=true)
    FileStreamDataStream.new(String name, std::ifstream s, size_t size)
    FileStreamDataStream.new(String name, std::fstream s, size_t size, bool freeOnClose=true)
    FileStreamDataStream.new(String name, std::fstream s, size_t size)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::FileStreamDataStream.read

  call-seq:
    read(void buf, size_t count) -> size_t

An instance method.

*/
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);
  {
    try {
      result = (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileStreamDataStream.write

  call-seq:
    write(void buf, size_t count) -> size_t

An instance method.

*/
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);
  {
    try {
      result = (arg1)->write((void const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileStreamDataStream.read_line

  call-seq:
    read_line(char buf, size_t maxCount, String delim="\n") -> size_t
    read_line(char buf, size_t maxCount) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_FileStreamDataStream_read_line__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;
  }
  {
    try {
      result = (arg1)->readLine(arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_read_line__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);
  {
    try {
      result = (arg1)->readLine(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_read_line(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_read_line__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_read_line__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FileStreamDataStream.read_line", 
    "    size_t FileStreamDataStream.read_line(char *buf, size_t maxCount, Ogre::String const &delim)\n"
    "    size_t FileStreamDataStream.read_line(char *buf, size_t maxCount)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::FileStreamDataStream.skip

  call-seq:
    skip(long count)

An instance method.

*/
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);
  {
    try {
      (arg1)->skip(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileStreamDataStream.seek

  call-seq:
    seek(size_t pos)

An instance method.

*/
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);
  {
    try {
      (arg1)->seek(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileStreamDataStream.tell

  call-seq:
    tell -> size_t

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::FileStreamDataStream const *)arg1)->tell();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileStreamDataStream.eof

  call-seq:
    eof -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::FileStreamDataStream const *)arg1)->eof();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileStreamDataStream.close

  call-seq:
    close

An instance method.

*/
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);
  {
    try {
      (arg1)->close();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::FileHandleDataStream < Ogre::Ogre::DataStream

  Proxy of C++ Ogre::FileHandleDataStream class


*/
swig_class SwigClassFileHandleDataStream;


/*
  Document-method: Ogre::FileHandleDataStream.new

  call-seq:
    FileHandleDataStream.new(FILE handle, uint16 accessMode=READ)
    FileHandleDataStream.new(FILE handle)
    FileHandleDataStream.new(String name, FILE handle, uint16 accessMode=READ)
    FileHandleDataStream.new(String name, FILE handle)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::FileHandleDataStream *)new Ogre::FileHandleDataStream(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::FileHandleDataStream *)new Ogre::FileHandleDataStream(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::FileHandleDataStream *)new Ogre::FileHandleDataStream((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::FileHandleDataStream *)new Ogre::FileHandleDataStream((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::FileHandleDataStream.read

  call-seq:
    read(void buf, size_t count) -> size_t

An instance method.

*/
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);
  {
    try {
      result = (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileHandleDataStream.write

  call-seq:
    write(void buf, size_t count) -> size_t

An instance method.

*/
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);
  {
    try {
      result = (arg1)->write((void const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileHandleDataStream.skip

  call-seq:
    skip(long count)

An instance method.

*/
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);
  {
    try {
      (arg1)->skip(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileHandleDataStream.seek

  call-seq:
    seek(size_t pos)

An instance method.

*/
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);
  {
    try {
      (arg1)->seek(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileHandleDataStream.tell

  call-seq:
    tell -> size_t

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::FileHandleDataStream const *)arg1)->tell();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileHandleDataStream.eof

  call-seq:
    eof -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::FileHandleDataStream const *)arg1)->eof();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileHandleDataStream.close

  call-seq:
    close

An instance method.

*/
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);
  {
    try {
      (arg1)->close();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::FileInfo

  Proxy of C++ Ogre::FileInfo class


*/
swig_class SwigClassFileInfo;


/*
  Document-method: Ogre::FileInfo.archive

  call-seq:
    archive -> Archive

Get value of attribute.

*/

/*
  Document-method: Ogre::FileInfo.archive=

  call-seq:
    archive=(x) -> Archive

Set new value for attribute.

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



/*
  Document-method: Ogre::FileInfo.filename

  call-seq:
    filename -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::FileInfo.filename=

  call-seq:
    filename=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::FileInfo.path

  call-seq:
    path -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::FileInfo.path=

  call-seq:
    path=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::FileInfo.basename

  call-seq:
    basename -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::FileInfo.basename=

  call-seq:
    basename=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::FileInfo.compressedSize

  call-seq:
    compressedSize -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::FileInfo.compressedSize=

  call-seq:
    compressedSize=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::FileInfo.uncompressedSize

  call-seq:
    uncompressedSize -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::FileInfo.uncompressedSize=

  call-seq:
    uncompressedSize=(x) -> size_t

Set new value for attribute.

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


/*
  Document-method: Ogre::FileInfo.new

  call-seq:
    FileInfo.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::FileInfo *)new Ogre::FileInfo();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FileInfo(Ogre::FileInfo *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::Archive

  Proxy of C++ Ogre::Archive class


*/
swig_class SwigClassArchive;

SWIGINTERN void
free_Ogre_Archive(Ogre::Archive *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Archive.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Archive_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Archive const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Archive.is_case_sensitive

  call-seq:
    is_case_sensitive -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Archive_is_case_sensitive(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);
  {
    try {
      result = (bool)((Ogre::Archive const *)arg1)->isCaseSensitive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Archive.load

  call-seq:
    load

An instance method.

*/
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);
  {
    try {
      (arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Archive.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Archive.is_read_only

  call-seq:
    is_read_only -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Archive_is_read_only(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);
  {
    try {
      result = (bool)((Ogre::Archive const *)arg1)->isReadOnly();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Archive.open

  call-seq:
    open(String filename, bool readOnly=true) -> DataStreamPtr
    open(String filename) -> DataStreamPtr

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Archive const *)arg1)->open((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
  }
  {
    try {
      result = ((Ogre::Archive const *)arg1)->open((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Archive.create

  call-seq:
    create(String filename) -> DataStreamPtr

An instance method.

*/
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;
  }
  {
    try {
      result = ((Ogre::Archive const *)arg1)->create((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Archive.remove

  call-seq:
    remove(String filename)

An instance method.

*/
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;
  }
  {
    try {
      ((Ogre::Archive const *)arg1)->remove((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Archive.list

  call-seq:
    list(bool recursive=true, bool dirs=false) -> StringVectorPtr
    list(bool recursive=true) -> StringVectorPtr
    list -> StringVectorPtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->list(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->list(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->list();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Archive.list_file_info

  call-seq:
    list_file_info(bool recursive=true, bool dirs=false) -> FileInfoListPtr
    list_file_info(bool recursive=true) -> FileInfoListPtr
    list_file_info -> FileInfoListPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Archive_list_file_info__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);
  {
    try {
      result = (arg1)->listFileInfo(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_list_file_info__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);
  {
    try {
      result = (arg1)->listFileInfo(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_list_file_info__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);
  {
    try {
      result = (arg1)->listFileInfo();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_list_file_info(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_file_info__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_file_info__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_file_info__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Archive.list_file_info", 
    "    Ogre::FileInfoListPtr Archive.list_file_info(bool recursive, bool dirs)\n"
    "    Ogre::FileInfoListPtr Archive.list_file_info(bool recursive)\n"
    "    Ogre::FileInfoListPtr Archive.list_file_info()\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);
  {
    try {
      result = (arg1)->find((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = (arg1)->find((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
  }
  {
    try {
      result = (arg1)->find((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Archive.exists

  call-seq:
    exists(String filename) -> bool

An instance method.

*/
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;
  }
  {
    try {
      result = (bool)(arg1)->exists((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Archive.get_modified_time

  call-seq:
    get_modified_time(String filename) -> time_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Archive_get_modified_time(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;
  }
  {
    try {
      result = (arg1)->getModifiedTime((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
}



/*
  Document-method: Ogre::Archive.find_file_info

  call-seq:
    find_file_info(String pattern, bool recursive=true, bool dirs=false) -> FileInfoListPtr
    find_file_info(String pattern, bool recursive=true) -> FileInfoListPtr
    find_file_info(String pattern) -> FileInfoListPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Archive_find_file_info__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);
  {
    try {
      result = ((Ogre::Archive const *)arg1)->findFileInfo((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_find_file_info__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);
  {
    try {
      result = ((Ogre::Archive const *)arg1)->findFileInfo((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_find_file_info__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;
  }
  {
    try {
      result = ((Ogre::Archive const *)arg1)->findFileInfo((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_find_file_info(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_file_info__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_file_info__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_file_info__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Archive.find_file_info", 
    "    Ogre::FileInfoListPtr Archive.find_file_info(Ogre::String const &pattern, bool recursive, bool dirs)\n"
    "    Ogre::FileInfoListPtr Archive.find_file_info(Ogre::String const &pattern, bool recursive)\n"
    "    Ogre::FileInfoListPtr Archive.find_file_info(Ogre::String const &pattern)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Archive.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Archive_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Archive const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ArchiveFactory

  Proxy of C++ Ogre::ArchiveFactory class


*/
swig_class SwigClassArchiveFactory;

SWIGINTERN void
free_Ogre_ArchiveFactory(Ogre::ArchiveFactory *arg1) {
    delete arg1;
}


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

  call-seq:
    fast_hash(char data, int len, uint32 hashSoFar=0) -> uint32
    fast_hash(char data, int len) -> uint32

A module function.

*/
SWIGINTERN VALUE
_wrap_fast_hash__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);
  {
    try {
      result = (Ogre::uint32)Ogre::FastHash((char const *)arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_fast_hash__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);
  {
    try {
      result = (Ogre::uint32)Ogre::FastHash((char const *)arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_fast_hash(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_fast_hash__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_fast_hash__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "fast_hash", 
    "    Ogre::uint32 fast_hash(char const *data, int len, Ogre::uint32 hashSoFar)\n"
    "    Ogre::uint32 fast_hash(char const *data, int len)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::Box

  Proxy of C++ Ogre::Box class


*/
swig_class SwigClassBox;


/*
  Document-method: Ogre::Box.left

  call-seq:
    left -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::Box.left=

  call-seq:
    left=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::Box.top

  call-seq:
    top -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::Box.top=

  call-seq:
    top=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::Box.right

  call-seq:
    right -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::Box.right=

  call-seq:
    right=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::Box.bottom

  call-seq:
    bottom -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::Box.bottom=

  call-seq:
    bottom=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::Box.new

  call-seq:
    Box.new
    Box.new(size_t l, size_t t, size_t r, size_t b)
    Box.new(size_t l, size_t t, size_t ff, size_t r, size_t b, 
    size_t bb)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Box *)new Ogre::Box();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Box *)new Ogre::Box(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::Box *)new Ogre::Box(arg1,arg2,arg3,arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::Box.contains

  call-seq:
    contains(Box def) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::Box const *)arg1)->contains((Ogre::Box const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Box.get_width

  call-seq:
    get_width -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Box_get_width(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);
  {
    try {
      result = ((Ogre::Box const *)arg1)->getWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Box.get_height

  call-seq:
    get_height -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Box_get_height(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);
  {
    try {
      result = ((Ogre::Box const *)arg1)->getHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Box.get_depth

  call-seq:
    get_depth -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Box_get_depth(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);
  {
    try {
      result = ((Ogre::Box const *)arg1)->getDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Box(Ogre::Box *arg1) {
    delete arg1;
}


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

  call-seq:
    find_command_line_opts(int numargs, char argv, UnaryOptionList unaryOptList, 
    BinaryOptionList binOptList) -> int

A module function.

*/
SWIGINTERN VALUE
_wrap_find_command_line_opts(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);
  {
    try {
      result = (int)Ogre::findCommandLineOpts(arg1,arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RenderWindowDescription

  Proxy of C++ Ogre::RenderWindowDescription class


*/
swig_class SwigClassRenderWindowDescription;


/*
  Document-method: Ogre::RenderWindowDescription.name

  call-seq:
    name -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderWindowDescription.name=

  call-seq:
    name=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::RenderWindowDescription.width

  call-seq:
    width -> unsigned int

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderWindowDescription.width=

  call-seq:
    width=(x) -> unsigned int

Set new value for attribute.

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



/*
  Document-method: Ogre::RenderWindowDescription.height

  call-seq:
    height -> unsigned int

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderWindowDescription.height=

  call-seq:
    height=(x) -> unsigned int

Set new value for attribute.

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



/*
  Document-method: Ogre::RenderWindowDescription.useFullScreen

  call-seq:
    useFullScreen -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderWindowDescription.useFullScreen=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::RenderWindowDescription.miscParams

  call-seq:
    miscParams -> NameValuePairList

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderWindowDescription.miscParams=

  call-seq:
    miscParams=(x) -> NameValuePairList

Set new value for attribute.

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


/*
  Document-method: Ogre::RenderWindowDescription.new

  call-seq:
    RenderWindowDescription.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderWindowDescription *)new Ogre::RenderWindowDescription();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderWindowDescription(Ogre::RenderWindowDescription *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::NameGenerator

  Proxy of C++ Ogre::NameGenerator class


*/
swig_class SwigClassNameGenerator;


/*
  Document-method: Ogre::NameGenerator.new

  call-seq:
    NameGenerator.new(NameGenerator rhs)
    NameGenerator.new(String prefix)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::NameGenerator *)new Ogre::NameGenerator((Ogre::NameGenerator const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      result = (Ogre::NameGenerator *)new Ogre::NameGenerator((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::NameGenerator.generate

  call-seq:
    generate -> String

An instance method.

*/
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);
  {
    try {
      result = (arg1)->generate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NameGenerator.reset

  call-seq:
    reset

An instance method.

*/
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);
  {
    try {
      (arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NameGenerator.set_next

  call-seq:
    set_next(unsigned long long val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_NameGenerator_set_next(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);
  {
    try {
      (arg1)->setNext(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NameGenerator.get_next

  call-seq:
    get_next -> unsigned long long

An instance method.

*/
SWIGINTERN VALUE
_wrap_NameGenerator_get_next(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);
  {
    try {
      result = (unsigned long long)((Ogre::NameGenerator const *)arg1)->getNext();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::ParameterDef

  Proxy of C++ Ogre::ParameterDef class


*/
swig_class SwigClassParameterDef;


/*
  Document-method: Ogre::ParameterDef.name

  call-seq:
    name -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ParameterDef.name=

  call-seq:
    name=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ParameterDef.description

  call-seq:
    description -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ParameterDef.description=

  call-seq:
    description=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ParameterDef.paramType

  call-seq:
    paramType -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::ParameterDef.paramType=

  call-seq:
    paramType=(x) -> int

Set new value for attribute.

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


/*
  Document-method: Ogre::ParameterDef.new

  call-seq:
    ParameterDef.new(String newName, String newDescription, ParameterType newType)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::ParameterDef *)new Ogre::ParameterDef((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::ParamCommand

  Proxy of C++ Ogre::ParamCommand class


*/
swig_class SwigClassParamCommand;


/*
  Document-method: Ogre::ParamCommand.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParamCommand_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::ParamCommand const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParamCommand.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParamCommand_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::ParamDictionary

  Proxy of C++ Ogre::ParamDictionary class


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


/*
  Document-method: Ogre::ParamDictionary.new

  call-seq:
    ParamDictionary.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ParamDictionary *)new Ogre::ParamDictionary();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParamDictionary.add_parameter

  call-seq:
    add_parameter(ParameterDef paramDef, ParamCommand paramCmd)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParamDictionary_add_parameter(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);
  {
    try {
      (arg1)->addParameter((Ogre::ParameterDef const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParamDictionary.get_parameters

  call-seq:
    get_parameters -> ParameterList

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParamDictionary_get_parameters(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);
  {
    try {
      result = (Ogre::ParameterList *) &((Ogre::ParamDictionary const *)arg1)->getParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}


/*
  Document-class: Ogre::StringInterface

  Proxy of C++ Ogre::StringInterface class


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


/*
  Document-method: Ogre::StringInterface.new

  call-seq:
    StringInterface.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::StringInterface *)new Ogre::StringInterface();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_StringInterface(Ogre::StringInterface *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::StringInterface.get_param_dictionary

  call-seq:
    get_param_dictionary -> ParamDictionary
    get_param_dictionary -> ParamDictionary

An instance method.

*/
SWIGINTERN VALUE
_wrap_StringInterface_get_param_dictionary__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);
  {
    try {
      result = (Ogre::ParamDictionary *)(arg1)->getParamDictionary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringInterface_get_param_dictionary__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);
  {
    try {
      result = (Ogre::ParamDictionary *)((Ogre::StringInterface const *)arg1)->getParamDictionary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringInterface_get_param_dictionary(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_get_param_dictionary__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_get_param_dictionary__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringInterface.get_param_dictionary", 
    "    Ogre::ParamDictionary const * StringInterface.get_param_dictionary()\n"
    "    Ogre::ParamDictionary const * StringInterface.get_param_dictionary()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.get_parameters

  call-seq:
    get_parameters -> ParameterList

An instance method.

*/
SWIGINTERN VALUE
_wrap_StringInterface_get_parameters(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);
  {
    try {
      result = (Ogre::ParameterList *) &((Ogre::StringInterface const *)arg1)->getParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.set_parameter

  call-seq:
    set_parameter(String name, String value) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_StringInterface_set_parameter(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;
  }
  {
    try {
      result = (bool)(arg1)->setParameter((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringInterface.set_parameter_list

  call-seq:
    set_parameter_list(NameValuePairList paramList)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StringInterface_set_parameter_list(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);
  {
    try {
      (arg1)->setParameterList((Ogre::NameValuePairList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.get_parameter

  call-seq:
    get_parameter(String name) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_StringInterface_get_parameter(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;
  }
  {
    try {
      result = ((Ogre::StringInterface const *)arg1)->getParameter((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringInterface.copy_parameters_to

  call-seq:
    copy_parameters_to(StringInterface dest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StringInterface_copy_parameters_to(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);
  {
    try {
      ((Ogre::StringInterface const *)arg1)->copyParametersTo(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.cleanup_dictionary

  call-seq:
    cleanup_dictionary

A class method.

*/
SWIGINTERN VALUE
_wrap_StringInterface_cleanup_dictionary(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      Ogre::StringInterface::cleanupDictionary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ResourceSharedPtr

  Proxy of C++ Ogre::ResourceSharedPtr class


*/
swig_class SwigClassResourceSharedPtr;


/*
  Document-method: Ogre::ResourceSharedPtr.new

  call-seq:
    ResourceSharedPtr.new
    ResourceSharedPtr.new(ResourceSharedPtr r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SharedPtr< Ogre::Resource > *)new Ogre::SharedPtr< Ogre::Resource >();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::SharedPtr< Ogre::Resource > *)new Ogre::SharedPtr< Ogre::Resource >((Ogre::SharedPtr< Ogre::Resource > const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::ResourceSharedPtr.__ref__

  call-seq:
    __ref__ -> Resource

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Resource *) &((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->operator *();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceSharedPtr.__deref__

  call-seq:
    __deref__ -> Resource

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Resource *)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->operator ->();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceSharedPtr.get

  call-seq:
    get -> Resource

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Resource *)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->get();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceSharedPtr.bind

  call-seq:
    bind(Resource rep, SharedPtrFreeMethod inFreeMethod=SPFM_DELETE)
    bind(Resource rep)

An instance method.

*/
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);
  {
    try {
      (arg1)->bind(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->bind(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::ResourceSharedPtr.unique

  call-seq:
    unique -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->unique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceSharedPtr.use_count

  call-seq:
    use_count -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_use_count(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);
  {
    try {
      result = (unsigned int)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->useCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceSharedPtr.use_count_pointer

  call-seq:
    use_count_pointer -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_use_count_pointer(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);
  {
    try {
      result = (unsigned int *)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->useCountPointer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceSharedPtr.get_pointer

  call-seq:
    get_pointer -> Resource

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_pointer(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);
  {
    try {
      result = (Ogre::Resource *)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->getPointer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceSharedPtr.free_method

  call-seq:
    free_method -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_free_method(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);
  {
    try {
      result = (Ogre::SharedPtrFreeMethod)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->freeMethod();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceSharedPtr.is_null

  call-seq:
    is_null -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_is_null(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);
  {
    try {
      result = (bool)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->isNull();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceSharedPtr.set_null

  call-seq:
    set_null

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_set_null(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);
  {
    try {
      (arg1)->setNull();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.prepare

  call-seq:
    prepare(bool backgroundThread=false)
    prepare

An instance method.

*/
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);
  {
    try {
      (*arg1)->prepare(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (*arg1)->prepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Resource.load

  call-seq:
    load(bool backgroundThread=false)
    load

An instance method.

*/
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);
  {
    try {
      (*arg1)->load(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (*arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Resource.reload

  call-seq:
    reload

An instance method.

*/
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);
  {
    try {
      (*arg1)->reload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_reloadable

  call-seq:
    is_reloadable -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_is_reloadable(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);
  {
    try {
      result = (bool)(*arg1)->isReloadable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_manually_loaded

  call-seq:
    is_manually_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_is_manually_loaded(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);
  {
    try {
      result = (bool)(*arg1)->isManuallyLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (*arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_size

  call-seq:
    get_size -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_size(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);
  {
    try {
      result = (*arg1)->getSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.touch

  call-seq:
    touch

An instance method.

*/
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);
  {
    try {
      (*arg1)->touch();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_name(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);
  {
    try {
      result = (Ogre::String *) &(*arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_handle

  call-seq:
    get_handle -> ResourceHandle

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_handle(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);
  {
    try {
      result = (Ogre::ResourceHandle)(*arg1)->getHandle();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_prepared

  call-seq:
    is_prepared -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_is_prepared(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);
  {
    try {
      result = (bool)(*arg1)->isPrepared();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_loaded

  call-seq:
    is_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_is_loaded(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);
  {
    try {
      result = (bool)(*arg1)->isLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_loading

  call-seq:
    is_loading -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_is_loading(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);
  {
    try {
      result = (bool)(*arg1)->isLoading();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_loading_state

  call-seq:
    get_loading_state -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_loading_state(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);
  {
    try {
      result = (Ogre::Resource::LoadingState)(*arg1)->getLoadingState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_background_loaded

  call-seq:
    is_background_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_is_background_loaded(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);
  {
    try {
      result = (bool)(*arg1)->isBackgroundLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.set_background_loaded

  call-seq:
    set_background_loaded(bool bl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_set_background_loaded(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);
  {
    try {
      (*arg1)->setBackgroundLoaded(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.escalate_loading

  call-seq:
    escalate_loading

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_escalate_loading(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);
  {
    try {
      (*arg1)->escalateLoading();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.add_listener

  call-seq:
    add_listener(Listener lis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_add_listener(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);
  {
    try {
      (*arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.remove_listener

  call-seq:
    remove_listener(Listener lis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_remove_listener(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);
  {
    try {
      (*arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_group

  call-seq:
    get_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_group(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);
  {
    try {
      result = (Ogre::String *) &(*arg1)->getGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.change_group_ownership

  call-seq:
    change_group_ownership(String newGroup)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_change_group_ownership(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;
  }
  {
    try {
      (*arg1)->changeGroupOwnership((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_creator

  call-seq:
    get_creator -> ResourceManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_creator(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);
  {
    try {
      result = (Ogre::ResourceManager *)(*arg1)->getCreator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_origin

  call-seq:
    get_origin -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_origin(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);
  {
    try {
      result = (Ogre::String *) &(*arg1)->getOrigin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._notify_origin

  call-seq:
    _notify_origin(String origin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr__notify_origin(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;
  }
  {
    try {
      (*arg1)->_notifyOrigin((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_state_count

  call-seq:
    get_state_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_state_count(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);
  {
    try {
      result = (*arg1)->getStateCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._dirty_state

  call-seq:
    _dirty_state

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr__dirty_state(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);
  {
    try {
      (*arg1)->_dirtyState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._fire_loading_complete

  call-seq:
    _fire_loading_complete(bool wasBackgroundLoaded)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr__fire_loading_complete(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);
  {
    try {
      (*arg1)->_fireLoadingComplete(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._fire_preparing_complete

  call-seq:
    _fire_preparing_complete(bool wasBackgroundLoaded)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr__fire_preparing_complete(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);
  {
    try {
      (*arg1)->_firePreparingComplete(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._fire_unloading_complete

  call-seq:
    _fire_unloading_complete

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr__fire_unloading_complete(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);
  {
    try {
      (*arg1)->_fireUnloadingComplete();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.get_param_dictionary

  call-seq:
    get_param_dictionary -> ParamDictionary
    get_param_dictionary -> ParamDictionary

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_param_dictionary__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);
  {
    try {
      result = (Ogre::ParamDictionary *)(*arg1)->getParamDictionary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_param_dictionary__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);
  {
    try {
      result = (Ogre::ParamDictionary *)(*arg1)->getParamDictionary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceSharedPtr_get_param_dictionary(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_get_param_dictionary__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_get_param_dictionary__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringInterface.get_param_dictionary", 
    "    Ogre::ParamDictionary const * StringInterface.get_param_dictionary()\n"
    "    Ogre::ParamDictionary const * StringInterface.get_param_dictionary()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.get_parameters

  call-seq:
    get_parameters -> ParameterList

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_parameters(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);
  {
    try {
      result = (Ogre::ParameterList *) &(*arg1)->getParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.set_parameter

  call-seq:
    set_parameter(String name, String value) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_set_parameter(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;
  }
  {
    try {
      result = (bool)(*arg1)->setParameter((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringInterface.set_parameter_list

  call-seq:
    set_parameter_list(NameValuePairList paramList)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_set_parameter_list(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);
  {
    try {
      (*arg1)->setParameterList((Ogre::NameValuePairList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.get_parameter

  call-seq:
    get_parameter(String name) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get_parameter(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;
  }
  {
    try {
      result = (*arg1)->getParameter((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringInterface.copy_parameters_to

  call-seq:
    copy_parameters_to(StringInterface dest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_copy_parameters_to(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);
  {
    try {
      (*arg1)->copyParametersTo(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.cleanup_dictionary

  call-seq:
    cleanup_dictionary

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceSharedPtr_cleanup_dictionary(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);
  {
    try {
      (*arg1)->cleanupDictionary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Resource < Ogre::Ogre::StringInterface

  Proxy of C++ Ogre::Resource class


*/
swig_class SwigClassResource;


/*
  Document-method: Ogre::LoadingState.LOADSTATE_UNLOADED

  call-seq:
    LOADSTATE_UNLOADED -> int

A class method.

*/

/*
  Document-method: Ogre::LoadingState.LOADSTATE_LOADING

  call-seq:
    LOADSTATE_LOADING -> int

A class method.

*/

/*
  Document-method: Ogre::LoadingState.LOADSTATE_LOADED

  call-seq:
    LOADSTATE_LOADED -> int

A class method.

*/

/*
  Document-method: Ogre::LoadingState.LOADSTATE_UNLOADING

  call-seq:
    LOADSTATE_UNLOADING -> int

A class method.

*/

/*
  Document-method: Ogre::LoadingState.LOADSTATE_PREPARED

  call-seq:
    LOADSTATE_PREPARED -> int

A class method.

*/

/*
  Document-method: Ogre::LoadingState.LOADSTATE_PREPARING

  call-seq:
    LOADSTATE_PREPARING -> int

A class method.

*/
SWIGINTERN void
free_Ogre_Resource(Ogre::Resource *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Resource.prepare

  call-seq:
    prepare(bool backgroundThread=false)
    prepare

An instance method.

*/
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);
  {
    try {
      (arg1)->prepare(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->prepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Resource.load

  call-seq:
    load(bool backgroundThread=false)
    load

An instance method.

*/
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);
  {
    try {
      (arg1)->load(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Resource.reload

  call-seq:
    reload

An instance method.

*/
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);
  {
    try {
      (arg1)->reload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_reloadable

  call-seq:
    is_reloadable -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_is_reloadable(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);
  {
    try {
      result = (bool)((Ogre::Resource const *)arg1)->isReloadable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_manually_loaded

  call-seq:
    is_manually_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_is_manually_loaded(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);
  {
    try {
      result = (bool)((Ogre::Resource const *)arg1)->isManuallyLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_size

  call-seq:
    get_size -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_get_size(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);
  {
    try {
      result = ((Ogre::Resource const *)arg1)->getSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.touch

  call-seq:
    touch

An instance method.

*/
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);
  {
    try {
      (arg1)->touch();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Resource const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_handle

  call-seq:
    get_handle -> ResourceHandle

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_get_handle(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);
  {
    try {
      result = (Ogre::ResourceHandle)((Ogre::Resource const *)arg1)->getHandle();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_prepared

  call-seq:
    is_prepared -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_is_prepared(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);
  {
    try {
      result = (bool)((Ogre::Resource const *)arg1)->isPrepared();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_loaded

  call-seq:
    is_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_is_loaded(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);
  {
    try {
      result = (bool)((Ogre::Resource const *)arg1)->isLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_loading

  call-seq:
    is_loading -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_is_loading(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);
  {
    try {
      result = (bool)((Ogre::Resource const *)arg1)->isLoading();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_loading_state

  call-seq:
    get_loading_state -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_get_loading_state(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);
  {
    try {
      result = (Ogre::Resource::LoadingState)((Ogre::Resource const *)arg1)->getLoadingState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_background_loaded

  call-seq:
    is_background_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_is_background_loaded(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);
  {
    try {
      result = (bool)((Ogre::Resource const *)arg1)->isBackgroundLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.set_background_loaded

  call-seq:
    set_background_loaded(bool bl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_set_background_loaded(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);
  {
    try {
      (arg1)->setBackgroundLoaded(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.escalate_loading

  call-seq:
    escalate_loading

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_escalate_loading(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);
  {
    try {
      (arg1)->escalateLoading();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.add_listener

  call-seq:
    add_listener(Listener lis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_add_listener(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);
  {
    try {
      (arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.remove_listener

  call-seq:
    remove_listener(Listener lis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_remove_listener(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);
  {
    try {
      (arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_group

  call-seq:
    get_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_get_group(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Resource const *)arg1)->getGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.change_group_ownership

  call-seq:
    change_group_ownership(String newGroup)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_change_group_ownership(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;
  }
  {
    try {
      (arg1)->changeGroupOwnership((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_creator

  call-seq:
    get_creator -> ResourceManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_get_creator(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);
  {
    try {
      result = (Ogre::ResourceManager *)(arg1)->getCreator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_origin

  call-seq:
    get_origin -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_get_origin(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Resource const *)arg1)->getOrigin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._notify_origin

  call-seq:
    _notify_origin(String origin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource__notify_origin(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;
  }
  {
    try {
      (arg1)->_notifyOrigin((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_state_count

  call-seq:
    get_state_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource_get_state_count(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);
  {
    try {
      result = ((Ogre::Resource const *)arg1)->getStateCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._dirty_state

  call-seq:
    _dirty_state

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource__dirty_state(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);
  {
    try {
      (arg1)->_dirtyState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._fire_loading_complete

  call-seq:
    _fire_loading_complete(bool wasBackgroundLoaded)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource__fire_loading_complete(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);
  {
    try {
      (arg1)->_fireLoadingComplete(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._fire_preparing_complete

  call-seq:
    _fire_preparing_complete(bool wasBackgroundLoaded)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource__fire_preparing_complete(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);
  {
    try {
      (arg1)->_firePreparingComplete(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._fire_unloading_complete

  call-seq:
    _fire_unloading_complete

An instance method.

*/
SWIGINTERN VALUE
_wrap_Resource__fire_unloading_complete(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);
  {
    try {
      (arg1)->_fireUnloadingComplete();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ManualResourceLoader

  Proxy of C++ Ogre::ManualResourceLoader class


*/
swig_class SwigClassManualResourceLoader;

SWIGINTERN void
free_Ogre_ManualResourceLoader(Ogre::ManualResourceLoader *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ManualResourceLoader.prepare_resource

  call-seq:
    prepare_resource(Resource resource)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualResourceLoader_prepare_resource(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);
  {
    try {
      (arg1)->prepareResource(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualResourceLoader.load_resource

  call-seq:
    load_resource(Resource resource)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualResourceLoader_load_resource(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);
  {
    try {
      (arg1)->loadResource(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ResourceGroupListener

  Proxy of C++ Ogre::ResourceGroupListener class


*/
swig_class SwigClassResourceGroupListener;

SWIGINTERN void
free_Ogre_ResourceGroupListener(Ogre::ResourceGroupListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ResourceGroupListener.resource_group_scripting_started

  call-seq:
    resource_group_scripting_started(String groupName, size_t scriptCount)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_resource_group_scripting_started(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);
  {
    try {
      (arg1)->resourceGroupScriptingStarted((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.script_parse_started

  call-seq:
    script_parse_started(String scriptName, bool skipThisScript)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_script_parse_started(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);
  {
    try {
      (arg1)->scriptParseStarted((Ogre::String const &)*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.script_parse_ended

  call-seq:
    script_parse_ended(String scriptName, bool skipped)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_script_parse_ended(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);
  {
    try {
      (arg1)->scriptParseEnded((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.resource_group_scripting_ended

  call-seq:
    resource_group_scripting_ended(String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_resource_group_scripting_ended(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;
  }
  {
    try {
      (arg1)->resourceGroupScriptingEnded((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.resource_group_prepare_started

  call-seq:
    resource_group_prepare_started(String groupName, size_t resourceCount)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_resource_group_prepare_started(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);
  {
    try {
      (arg1)->resourceGroupPrepareStarted((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.resource_prepare_started

  call-seq:
    resource_prepare_started(ResourcePtr resource)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_resource_prepare_started(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);
  {
    try {
      (arg1)->resourcePrepareStarted((Ogre::ResourcePtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.resource_prepare_ended

  call-seq:
    resource_prepare_ended

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_resource_prepare_ended(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);
  {
    try {
      (arg1)->resourcePrepareEnded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.world_geometry_prepare_stage_started

  call-seq:
    world_geometry_prepare_stage_started(String description)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_world_geometry_prepare_stage_started(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;
  }
  {
    try {
      (arg1)->worldGeometryPrepareStageStarted((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.world_geometry_prepare_stage_ended

  call-seq:
    world_geometry_prepare_stage_ended

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_world_geometry_prepare_stage_ended(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);
  {
    try {
      (arg1)->worldGeometryPrepareStageEnded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.resource_group_prepare_ended

  call-seq:
    resource_group_prepare_ended(String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_resource_group_prepare_ended(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;
  }
  {
    try {
      (arg1)->resourceGroupPrepareEnded((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.resource_group_load_started

  call-seq:
    resource_group_load_started(String groupName, size_t resourceCount)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_resource_group_load_started(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);
  {
    try {
      (arg1)->resourceGroupLoadStarted((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.resource_load_started

  call-seq:
    resource_load_started(ResourcePtr resource)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_resource_load_started(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);
  {
    try {
      (arg1)->resourceLoadStarted((Ogre::ResourcePtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.resource_load_ended

  call-seq:
    resource_load_ended

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_resource_load_ended(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);
  {
    try {
      (arg1)->resourceLoadEnded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.world_geometry_stage_started

  call-seq:
    world_geometry_stage_started(String description)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_world_geometry_stage_started(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;
  }
  {
    try {
      (arg1)->worldGeometryStageStarted((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.world_geometry_stage_ended

  call-seq:
    world_geometry_stage_ended

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_world_geometry_stage_ended(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);
  {
    try {
      (arg1)->worldGeometryStageEnded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupListener.resource_group_load_ended

  call-seq:
    resource_group_load_ended(String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupListener_resource_group_load_ended(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;
  }
  {
    try {
      (arg1)->resourceGroupLoadEnded((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-class: Ogre::ResourceLoadingListener

  Proxy of C++ Ogre::ResourceLoadingListener class


*/
swig_class SwigClassResourceLoadingListener;

SWIGINTERN void
free_Ogre_ResourceLoadingListener(Ogre::ResourceLoadingListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ResourceLoadingListener.resource_loading

  call-seq:
    resource_loading(String name, String group, Resource resource) -> DataStreamPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceLoadingListener_resource_loading(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);
  {
    try {
      result = (arg1)->resourceLoading((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
}



/*
  Document-method: Ogre::ResourceLoadingListener.resource_stream_opened

  call-seq:
    resource_stream_opened(String name, String group, Resource resource, DataStreamPtr dataStream)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceLoadingListener_resource_stream_opened(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);
  {
    try {
      (arg1)->resourceStreamOpened((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceLoadingListener.resource_collision

  call-seq:
    resource_collision(Resource resource, ResourceManager resourceManager) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceLoadingListener_resource_collision(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);
  {
    try {
      result = (bool)(arg1)->resourceCollision(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ResourceGroupManager

  Proxy of C++ Ogre::ResourceGroupManager class


*/
swig_class SwigClassResourceGroupManager;


/*
  Document-method: Ogre::ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME

  call-seq:
    DEFAULT_RESOURCE_GROUP_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME=

  call-seq:
    DEFAULT_RESOURCE_GROUP_NAME=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::ResourceGroupManager.ResourceGroupManager_DEFAULT_RESOURCE_GROUP_NAME

  call-seq:
    ResourceGroupManager_DEFAULT_RESOURCE_GROUP_NAME -> String

Get value of attribute.

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



/*
  Document-method: Ogre::ResourceGroupManager.ResourceGroupManager_DEFAULT_RESOURCE_GROUP_NAME=

  call-seq:
    ResourceGroupManager_DEFAULT_RESOURCE_GROUP_NAME=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ResourceGroupManager.INTERNAL_RESOURCE_GROUP_NAME

  call-seq:
    INTERNAL_RESOURCE_GROUP_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ResourceGroupManager.INTERNAL_RESOURCE_GROUP_NAME=

  call-seq:
    INTERNAL_RESOURCE_GROUP_NAME=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::ResourceGroupManager.ResourceGroupManager_INTERNAL_RESOURCE_GROUP_NAME

  call-seq:
    ResourceGroupManager_INTERNAL_RESOURCE_GROUP_NAME -> String

Get value of attribute.

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



/*
  Document-method: Ogre::ResourceGroupManager.ResourceGroupManager_INTERNAL_RESOURCE_GROUP_NAME=

  call-seq:
    ResourceGroupManager_INTERNAL_RESOURCE_GROUP_NAME=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ResourceGroupManager.AUTODETECT_RESOURCE_GROUP_NAME

  call-seq:
    AUTODETECT_RESOURCE_GROUP_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ResourceGroupManager.AUTODETECT_RESOURCE_GROUP_NAME=

  call-seq:
    AUTODETECT_RESOURCE_GROUP_NAME=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::ResourceGroupManager.ResourceGroupManager_AUTODETECT_RESOURCE_GROUP_NAME

  call-seq:
    ResourceGroupManager_AUTODETECT_RESOURCE_GROUP_NAME -> String

Get value of attribute.

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



/*
  Document-method: Ogre::ResourceGroupManager.ResourceGroupManager_AUTODETECT_RESOURCE_GROUP_NAME=

  call-seq:
    ResourceGroupManager_AUTODETECT_RESOURCE_GROUP_NAME=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ResourceGroupManager.RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS

  call-seq:
    RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::ResourceGroupManager.RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS=

  call-seq:
    RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS=(x) -> size_t

Set new value for attribute.

*/

/*
  Document-method: Ogre::ResourceGroupManager.ResourceGroupManager_RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS

  call-seq:
    ResourceGroupManager_RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS -> size_t

Get value of attribute.

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



/*
  Document-method: Ogre::ResourceGroupManager.ResourceGroupManager_RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS=

  call-seq:
    ResourceGroupManager_RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS=(x) -> size_t

Set new value for attribute.

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


/*
  Document-method: Ogre::ResourceGroupManager.new

  call-seq:
    ResourceGroupManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ResourceGroupManager *)new Ogre::ResourceGroupManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ResourceGroupManager(Ogre::ResourceGroupManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ResourceGroupManager.create_resource_group

  call-seq:
    create_resource_group(String name, bool inGlobalPool=true)
    create_resource_group(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_create_resource_group__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);
  {
    try {
      (arg1)->createResourceGroup((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_create_resource_group__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;
  }
  {
    try {
      (arg1)->createResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_create_resource_group(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_create_resource_group__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_create_resource_group__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.create_resource_group", 
    "    void ResourceGroupManager.create_resource_group(Ogre::String const &name, bool const inGlobalPool)\n"
    "    void ResourceGroupManager.create_resource_group(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.initialise_resource_group

  call-seq:
    initialise_resource_group(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_initialise_resource_group(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;
  }
  {
    try {
      (arg1)->initialiseResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.initialise_all_resource_groups

  call-seq:
    initialise_all_resource_groups

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_initialise_all_resource_groups(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);
  {
    try {
      (arg1)->initialiseAllResourceGroups();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.prepare_resource_group

  call-seq:
    prepare_resource_group(String name, bool prepareMainResources=true, bool prepareWorldGeom=true)
    prepare_resource_group(String name, bool prepareMainResources=true)
    prepare_resource_group(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_prepare_resource_group__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);
  {
    try {
      (arg1)->prepareResourceGroup((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_prepare_resource_group__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);
  {
    try {
      (arg1)->prepareResourceGroup((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_prepare_resource_group__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;
  }
  {
    try {
      (arg1)->prepareResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_prepare_resource_group(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_prepare_resource_group__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_prepare_resource_group__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_prepare_resource_group__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceGroupManager.prepare_resource_group", 
    "    void ResourceGroupManager.prepare_resource_group(Ogre::String const &name, bool prepareMainResources, bool prepareWorldGeom)\n"
    "    void ResourceGroupManager.prepare_resource_group(Ogre::String const &name, bool prepareMainResources)\n"
    "    void ResourceGroupManager.prepare_resource_group(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.load_resource_group

  call-seq:
    load_resource_group(String name, bool loadMainResources=true, bool loadWorldGeom=true)
    load_resource_group(String name, bool loadMainResources=true)
    load_resource_group(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_load_resource_group__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);
  {
    try {
      (arg1)->loadResourceGroup((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_load_resource_group__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);
  {
    try {
      (arg1)->loadResourceGroup((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_load_resource_group__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;
  }
  {
    try {
      (arg1)->loadResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_load_resource_group(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_load_resource_group__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_load_resource_group__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_load_resource_group__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceGroupManager.load_resource_group", 
    "    void ResourceGroupManager.load_resource_group(Ogre::String const &name, bool loadMainResources, bool loadWorldGeom)\n"
    "    void ResourceGroupManager.load_resource_group(Ogre::String const &name, bool loadMainResources)\n"
    "    void ResourceGroupManager.load_resource_group(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.unload_resource_group

  call-seq:
    unload_resource_group(String name, bool reloadableOnly=true)
    unload_resource_group(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_unload_resource_group__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);
  {
    try {
      (arg1)->unloadResourceGroup((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_unload_resource_group__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;
  }
  {
    try {
      (arg1)->unloadResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_unload_resource_group(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_unload_resource_group__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_unload_resource_group__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.unload_resource_group", 
    "    void ResourceGroupManager.unload_resource_group(Ogre::String const &name, bool reloadableOnly)\n"
    "    void ResourceGroupManager.unload_resource_group(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.unload_unreferenced_resources_in_group

  call-seq:
    unload_unreferenced_resources_in_group(String name, bool reloadableOnly=true)
    unload_unreferenced_resources_in_group(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_unload_unreferenced_resources_in_group__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);
  {
    try {
      (arg1)->unloadUnreferencedResourcesInGroup((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_unload_unreferenced_resources_in_group__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;
  }
  {
    try {
      (arg1)->unloadUnreferencedResourcesInGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_unload_unreferenced_resources_in_group(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_unload_unreferenced_resources_in_group__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_unload_unreferenced_resources_in_group__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.unload_unreferenced_resources_in_group", 
    "    void ResourceGroupManager.unload_unreferenced_resources_in_group(Ogre::String const &name, bool reloadableOnly)\n"
    "    void ResourceGroupManager.unload_unreferenced_resources_in_group(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.clear_resource_group

  call-seq:
    clear_resource_group(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_clear_resource_group(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;
  }
  {
    try {
      (arg1)->clearResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.destroy_resource_group

  call-seq:
    destroy_resource_group(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_destroy_resource_group(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;
  }
  {
    try {
      (arg1)->destroyResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.is_resource_group_initialised

  call-seq:
    is_resource_group_initialised(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_is_resource_group_initialised(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;
  }
  {
    try {
      result = (bool)(arg1)->isResourceGroupInitialised((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.is_resource_group_loaded

  call-seq:
    is_resource_group_loaded(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_is_resource_group_loaded(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;
  }
  {
    try {
      result = (bool)(arg1)->isResourceGroupLoaded((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.resource_group_exists

  call-seq:
    resource_group_exists(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_resource_group_exists(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;
  }
  {
    try {
      result = (bool)(arg1)->resourceGroupExists((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.add_resource_location

  call-seq:
    add_resource_location(String name, String locType, String resGroup=DEFAULT_RESOURCE_GROUP_NAME, 
    bool recursive=false)
    add_resource_location(String name, String locType, String resGroup=DEFAULT_RESOURCE_GROUP_NAME)
    add_resource_location(String name, String locType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_add_resource_location__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);
  {
    try {
      (arg1)->addResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_add_resource_location__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;
  }
  {
    try {
      (arg1)->addResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_add_resource_location__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;
  }
  {
    try {
      (arg1)->addResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_add_resource_location(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_add_resource_location__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_add_resource_location__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_add_resource_location__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ResourceGroupManager.add_resource_location", 
    "    void ResourceGroupManager.add_resource_location(Ogre::String const &name, Ogre::String const &locType, Ogre::String const &resGroup, bool recursive)\n"
    "    void ResourceGroupManager.add_resource_location(Ogre::String const &name, Ogre::String const &locType, Ogre::String const &resGroup)\n"
    "    void ResourceGroupManager.add_resource_location(Ogre::String const &name, Ogre::String const &locType)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.remove_resource_location

  call-seq:
    remove_resource_location(String name, String resGroup=DEFAULT_RESOURCE_GROUP_NAME)
    remove_resource_location(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_remove_resource_location__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;
  }
  {
    try {
      (arg1)->removeResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_remove_resource_location__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;
  }
  {
    try {
      (arg1)->removeResourceLocation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_remove_resource_location(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_remove_resource_location__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_remove_resource_location__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.remove_resource_location", 
    "    void ResourceGroupManager.remove_resource_location(Ogre::String const &name, Ogre::String const &resGroup)\n"
    "    void ResourceGroupManager.remove_resource_location(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.resource_location_exists

  call-seq:
    resource_location_exists(String name, String resGroup=DEFAULT_RESOURCE_GROUP_NAME) -> bool
    resource_location_exists(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_resource_location_exists__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;
  }
  {
    try {
      result = (bool)(arg1)->resourceLocationExists((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_resource_location_exists__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;
  }
  {
    try {
      result = (bool)(arg1)->resourceLocationExists((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_resource_location_exists(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_resource_location_exists__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_resource_location_exists__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.resource_location_exists", 
    "    bool ResourceGroupManager.resource_location_exists(Ogre::String const &name, Ogre::String const &resGroup)\n"
    "    bool ResourceGroupManager.resource_location_exists(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.declare_resource

  call-seq:
    declare_resource(String name, String resourceType, String groupName=DEFAULT_RESOURCE_GROUP_NAME, 
    NameValuePairList loadParameters=Ogre::NameValuePairList())
    declare_resource(String name, String resourceType, String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    declare_resource(String name, String resourceType)
    declare_resource(String name, String resourceType, String groupName, 
    ManualResourceLoader loader, NameValuePairList loadParameters=Ogre::NameValuePairList())
    declare_resource(String name, String resourceType, String groupName, 
    ManualResourceLoader loader)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_declare_resource__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);
  {
    try {
      (arg1)->declareResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,(Ogre::NameValuePairList const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_declare_resource__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;
  }
  {
    try {
      (arg1)->declareResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_declare_resource__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;
  }
  {
    try {
      (arg1)->declareResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_declare_resource__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);
  {
    try {
      (arg1)->declareResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,(Ogre::NameValuePairList const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_declare_resource__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);
  {
    try {
      (arg1)->declareResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_declare_resource(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_declare_resource__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_declare_resource__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_declare_resource__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_declare_resource__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_declare_resource__SWIG_3(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "ResourceGroupManager.declare_resource", 
    "    void ResourceGroupManager.declare_resource(Ogre::String const &name, Ogre::String const &resourceType, Ogre::String const &groupName, Ogre::NameValuePairList const &loadParameters)\n"
    "    void ResourceGroupManager.declare_resource(Ogre::String const &name, Ogre::String const &resourceType, Ogre::String const &groupName)\n"
    "    void ResourceGroupManager.declare_resource(Ogre::String const &name, Ogre::String const &resourceType)\n"
    "    void ResourceGroupManager.declare_resource(Ogre::String const &name, Ogre::String const &resourceType, Ogre::String const &groupName, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const &loadParameters)\n"
    "    void ResourceGroupManager.declare_resource(Ogre::String const &name, Ogre::String const &resourceType, Ogre::String const &groupName, Ogre::ManualResourceLoader *loader)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.undeclare_resource

  call-seq:
    undeclare_resource(String name, String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_undeclare_resource(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;
  }
  {
    try {
      (arg1)->undeclareResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::ResourceGroupManager.open_resource

  call-seq:
    open_resource(String resourceName, String groupName=DEFAULT_RESOURCE_GROUP_NAME, 
    bool searchGroupsIfNotFound=true, 
    Resource resourceBeingLoaded=0) -> DataStreamPtr
    open_resource(String resourceName, String groupName=DEFAULT_RESOURCE_GROUP_NAME, 
    bool searchGroupsIfNotFound=true) -> DataStreamPtr
    open_resource(String resourceName, String groupName=DEFAULT_RESOURCE_GROUP_NAME) -> DataStreamPtr
    open_resource(String resourceName) -> DataStreamPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_open_resource__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);
  {
    try {
      result = (arg1)->openResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_open_resource__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);
  {
    try {
      result = (arg1)->openResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_open_resource__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;
  }
  {
    try {
      result = (arg1)->openResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_open_resource__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;
  }
  {
    try {
      result = (arg1)->openResource((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_open_resource(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_open_resource__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_open_resource__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_open_resource__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_open_resource__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ResourceGroupManager.open_resource", 
    "    Ogre::DataStreamPtr ResourceGroupManager.open_resource(Ogre::String const &resourceName, Ogre::String const &groupName, bool searchGroupsIfNotFound, Ogre::Resource *resourceBeingLoaded)\n"
    "    Ogre::DataStreamPtr ResourceGroupManager.open_resource(Ogre::String const &resourceName, Ogre::String const &groupName, bool searchGroupsIfNotFound)\n"
    "    Ogre::DataStreamPtr ResourceGroupManager.open_resource(Ogre::String const &resourceName, Ogre::String const &groupName)\n"
    "    Ogre::DataStreamPtr ResourceGroupManager.open_resource(Ogre::String const &resourceName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.open_resources

  call-seq:
    open_resources(String pattern, String groupName=DEFAULT_RESOURCE_GROUP_NAME) -> DataStreamListPtr
    open_resources(String pattern) -> DataStreamListPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_open_resources__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;
  }
  {
    try {
      result = (arg1)->openResources((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_open_resources__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;
  }
  {
    try {
      result = (arg1)->openResources((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_open_resources(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_open_resources__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_open_resources__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.open_resources", 
    "    Ogre::DataStreamListPtr ResourceGroupManager.open_resources(Ogre::String const &pattern, Ogre::String const &groupName)\n"
    "    Ogre::DataStreamListPtr ResourceGroupManager.open_resources(Ogre::String const &pattern)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.list_resource_names

  call-seq:
    list_resource_names(String groupName, bool dirs=false) -> StringVectorPtr
    list_resource_names(String groupName) -> StringVectorPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_list_resource_names__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);
  {
    try {
      result = (arg1)->listResourceNames((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_list_resource_names__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;
  }
  {
    try {
      result = (arg1)->listResourceNames((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_list_resource_names(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_list_resource_names__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_list_resource_names__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.list_resource_names", 
    "    Ogre::StringVectorPtr ResourceGroupManager.list_resource_names(Ogre::String const &groupName, bool dirs)\n"
    "    Ogre::StringVectorPtr ResourceGroupManager.list_resource_names(Ogre::String const &groupName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.list_resource_file_info

  call-seq:
    list_resource_file_info(String groupName, bool dirs=false) -> FileInfoListPtr
    list_resource_file_info(String groupName) -> FileInfoListPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_list_resource_file_info__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);
  {
    try {
      result = (arg1)->listResourceFileInfo((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_list_resource_file_info__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;
  }
  {
    try {
      result = (arg1)->listResourceFileInfo((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_list_resource_file_info(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_list_resource_file_info__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_list_resource_file_info__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.list_resource_file_info", 
    "    Ogre::FileInfoListPtr ResourceGroupManager.list_resource_file_info(Ogre::String const &groupName, bool dirs)\n"
    "    Ogre::FileInfoListPtr ResourceGroupManager.list_resource_file_info(Ogre::String const &groupName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.find_resource_names

  call-seq:
    find_resource_names(String groupName, String pattern, bool dirs=false) -> StringVectorPtr
    find_resource_names(String groupName, String pattern) -> StringVectorPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_find_resource_names__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);
  {
    try {
      result = (arg1)->findResourceNames((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_find_resource_names__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;
  }
  {
    try {
      result = (arg1)->findResourceNames((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_find_resource_names(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_find_resource_names__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_find_resource_names__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceGroupManager.find_resource_names", 
    "    Ogre::StringVectorPtr ResourceGroupManager.find_resource_names(Ogre::String const &groupName, Ogre::String const &pattern, bool dirs)\n"
    "    Ogre::StringVectorPtr ResourceGroupManager.find_resource_names(Ogre::String const &groupName, Ogre::String const &pattern)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.resource_exists_in_any_group

  call-seq:
    resource_exists_in_any_group(String filename) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_resource_exists_in_any_group(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;
  }
  {
    try {
      result = (bool)(arg1)->resourceExistsInAnyGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.find_group_containing_resource

  call-seq:
    find_group_containing_resource(String filename) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_find_group_containing_resource(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;
  }
  {
    try {
      result = (Ogre::String *) &(arg1)->findGroupContainingResource((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::ResourceGroupManager.find_resource_file_info

  call-seq:
    find_resource_file_info(String group, String pattern, bool dirs=false) -> FileInfoListPtr
    find_resource_file_info(String group, String pattern) -> FileInfoListPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_find_resource_file_info__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);
  {
    try {
      result = (arg1)->findResourceFileInfo((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_find_resource_file_info__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;
  }
  {
    try {
      result = (arg1)->findResourceFileInfo((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_find_resource_file_info(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_find_resource_file_info__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_find_resource_file_info__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceGroupManager.find_resource_file_info", 
    "    Ogre::FileInfoListPtr ResourceGroupManager.find_resource_file_info(Ogre::String const &group, Ogre::String const &pattern, bool dirs)\n"
    "    Ogre::FileInfoListPtr ResourceGroupManager.find_resource_file_info(Ogre::String const &group, Ogre::String const &pattern)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.list_resource_locations

  call-seq:
    list_resource_locations(String groupName) -> StringVectorPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_list_resource_locations(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;
  }
  {
    try {
      result = (arg1)->listResourceLocations((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ResourceGroupManager.find_resource_location

  call-seq:
    find_resource_location(String groupName, String pattern) -> StringVectorPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_find_resource_location(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;
  }
  {
    try {
      result = (arg1)->findResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ResourceGroupManager.create_resource

  call-seq:
    create_resource(String filename, String groupName=DEFAULT_RESOURCE_GROUP_NAME, 
    bool overwrite=false, String locationPattern=BLANK) -> DataStreamPtr
    create_resource(String filename, String groupName=DEFAULT_RESOURCE_GROUP_NAME, 
    bool overwrite=false) -> DataStreamPtr
    create_resource(String filename, String groupName=DEFAULT_RESOURCE_GROUP_NAME) -> DataStreamPtr
    create_resource(String filename) -> DataStreamPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_create_resource__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;
  }
  {
    try {
      result = (arg1)->createResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_create_resource__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);
  {
    try {
      result = (arg1)->createResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_create_resource__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;
  }
  {
    try {
      result = (arg1)->createResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_resource__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;
  }
  {
    try {
      result = (arg1)->createResource((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_resource(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_create_resource__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_create_resource__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_create_resource__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_create_resource__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ResourceGroupManager.create_resource", 
    "    Ogre::DataStreamPtr ResourceGroupManager.create_resource(Ogre::String const &filename, Ogre::String const &groupName, bool overwrite, Ogre::String const &locationPattern)\n"
    "    Ogre::DataStreamPtr ResourceGroupManager.create_resource(Ogre::String const &filename, Ogre::String const &groupName, bool overwrite)\n"
    "    Ogre::DataStreamPtr ResourceGroupManager.create_resource(Ogre::String const &filename, Ogre::String const &groupName)\n"
    "    Ogre::DataStreamPtr ResourceGroupManager.create_resource(Ogre::String const &filename)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.delete_resource

  call-seq:
    delete_resource(String filename, String groupName=DEFAULT_RESOURCE_GROUP_NAME, 
    String locationPattern=BLANK)
    delete_resource(String filename, String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    delete_resource(String filename)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_delete_resource__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;
  }
  {
    try {
      (arg1)->deleteResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_delete_resource__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;
  }
  {
    try {
      (arg1)->deleteResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_delete_resource__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;
  }
  {
    try {
      (arg1)->deleteResource((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_delete_resource(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_delete_resource__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_delete_resource__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_delete_resource__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceGroupManager.delete_resource", 
    "    void ResourceGroupManager.delete_resource(Ogre::String const &filename, Ogre::String const &groupName, Ogre::String const &locationPattern)\n"
    "    void ResourceGroupManager.delete_resource(Ogre::String const &filename, Ogre::String const &groupName)\n"
    "    void ResourceGroupManager.delete_resource(Ogre::String const &filename)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.delete_matching_resources

  call-seq:
    delete_matching_resources(String filePattern, String groupName=DEFAULT_RESOURCE_GROUP_NAME, 
    String locationPattern=BLANK)
    delete_matching_resources(String filePattern, String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    delete_matching_resources(String filePattern)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_delete_matching_resources__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;
  }
  {
    try {
      (arg1)->deleteMatchingResources((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_delete_matching_resources__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;
  }
  {
    try {
      (arg1)->deleteMatchingResources((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_delete_matching_resources__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;
  }
  {
    try {
      (arg1)->deleteMatchingResources((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_delete_matching_resources(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_delete_matching_resources__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_delete_matching_resources__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_delete_matching_resources__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceGroupManager.delete_matching_resources", 
    "    void ResourceGroupManager.delete_matching_resources(Ogre::String const &filePattern, Ogre::String const &groupName, Ogre::String const &locationPattern)\n"
    "    void ResourceGroupManager.delete_matching_resources(Ogre::String const &filePattern, Ogre::String const &groupName)\n"
    "    void ResourceGroupManager.delete_matching_resources(Ogre::String const &filePattern)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.add_resource_group_listener

  call-seq:
    add_resource_group_listener(ResourceGroupListener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_add_resource_group_listener(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);
  {
    try {
      (arg1)->addResourceGroupListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.remove_resource_group_listener

  call-seq:
    remove_resource_group_listener(ResourceGroupListener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_remove_resource_group_listener(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);
  {
    try {
      (arg1)->removeResourceGroupListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.set_world_resource_group_name

  call-seq:
    set_world_resource_group_name(String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_set_world_resource_group_name(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;
  }
  {
    try {
      (arg1)->setWorldResourceGroupName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.get_world_resource_group_name

  call-seq:
    get_world_resource_group_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_get_world_resource_group_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ResourceGroupManager const *)arg1)->getWorldResourceGroupName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.link_world_geometry_to_resource_group

  call-seq:
    link_world_geometry_to_resource_group(String group, String worldGeometry, SceneManager sceneManager)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_link_world_geometry_to_resource_group(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);
  {
    try {
      (arg1)->linkWorldGeometryToResourceGroup((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.unlink_world_geometry_from_resource_group

  call-seq:
    unlink_world_geometry_from_resource_group(String group)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_unlink_world_geometry_from_resource_group(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;
  }
  {
    try {
      (arg1)->unlinkWorldGeometryFromResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.is_resource_group_in_global_pool

  call-seq:
    is_resource_group_in_global_pool(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_is_resource_group_in_global_pool(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;
  }
  {
    try {
      result = (bool)(arg1)->isResourceGroupInGlobalPool((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.shutdown_all

  call-seq:
    shutdown_all

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_shutdown_all(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);
  {
    try {
      (arg1)->shutdownAll();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager._register_resource_manager

  call-seq:
    _register_resource_manager(String resourceType, ResourceManager rm)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager__register_resource_manager(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);
  {
    try {
      (arg1)->_registerResourceManager((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager._unregister_resource_manager

  call-seq:
    _unregister_resource_manager(String resourceType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager__unregister_resource_manager(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;
  }
  {
    try {
      (arg1)->_unregisterResourceManager((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.get_resource_manager_iterator

  call-seq:
    get_resource_manager_iterator -> ResourceManagerIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_get_resource_manager_iterator(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);
  {
    try {
      result = (arg1)->getResourceManagerIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ResourceGroupManager::ResourceManagerIterator(static_cast< const Ogre::ResourceGroupManager::ResourceManagerIterator& >(result))), SWIGTYPE_p_Ogre__ResourceGroupManager__ResourceManagerIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager._register_script_loader

  call-seq:
    _register_script_loader(ScriptLoader su)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager__register_script_loader(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);
  {
    try {
      (arg1)->_registerScriptLoader(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager._unregister_script_loader

  call-seq:
    _unregister_script_loader(ScriptLoader su)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager__unregister_script_loader(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);
  {
    try {
      (arg1)->_unregisterScriptLoader(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager._find_script_loader

  call-seq:
    _find_script_loader(String pattern) -> ScriptLoader

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager__find_script_loader(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;
  }
  {
    try {
      result = (Ogre::ScriptLoader *)(arg1)->_findScriptLoader((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptLoader, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager._get_resource_manager

  call-seq:
    _get_resource_manager(String resourceType) -> ResourceManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager__get_resource_manager(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;
  }
  {
    try {
      result = (Ogre::ResourceManager *)(arg1)->_getResourceManager((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager._notify_resource_created

  call-seq:
    _notify_resource_created(ResourcePtr res)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager__notify_resource_created(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);
  {
    try {
      (arg1)->_notifyResourceCreated(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager._notify_resource_removed

  call-seq:
    _notify_resource_removed(ResourcePtr res)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager__notify_resource_removed(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);
  {
    try {
      (arg1)->_notifyResourceRemoved(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager._notify_resource_group_changed

  call-seq:
    _notify_resource_group_changed(String oldGroup, Resource res)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager__notify_resource_group_changed(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);
  {
    try {
      (arg1)->_notifyResourceGroupChanged((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager._notify_all_resources_removed

  call-seq:
    _notify_all_resources_removed(ResourceManager manager)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager__notify_all_resources_removed(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);
  {
    try {
      (arg1)->_notifyAllResourcesRemoved(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager._notify_world_geometry_stage_started

  call-seq:
    _notify_world_geometry_stage_started(String description)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager__notify_world_geometry_stage_started(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;
  }
  {
    try {
      (arg1)->_notifyWorldGeometryStageStarted((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager._notify_world_geometry_stage_ended

  call-seq:
    _notify_world_geometry_stage_ended

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager__notify_world_geometry_stage_ended(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);
  {
    try {
      (arg1)->_notifyWorldGeometryStageEnded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.get_resource_groups

  call-seq:
    get_resource_groups -> StringVector

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_get_resource_groups(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);
  {
    try {
      result = (arg1)->getResourceGroups();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ResourceGroupManager.get_resource_declaration_list

  call-seq:
    get_resource_declaration_list(String groupName) -> ResourceDeclarationList

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_get_resource_declaration_list(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;
  }
  {
    try {
      result = (arg1)->getResourceDeclarationList((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ResourceGroupManager.get_resource_location_list

  call-seq:
    get_resource_location_list(String groupName) -> LocationList

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_get_resource_location_list(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;
  }
  {
    try {
      result = (Ogre::ResourceGroupManager::LocationList *) &(arg1)->getResourceLocationList((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
}



/*
  Document-method: Ogre::ResourceGroupManager.set_loading_listener

  call-seq:
    set_loading_listener(ResourceLoadingListener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_set_loading_listener(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);
  {
    try {
      (arg1)->setLoadingListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.get_loading_listener

  call-seq:
    get_loading_listener -> ResourceLoadingListener

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_get_loading_listener(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);
  {
    try {
      result = (Ogre::ResourceLoadingListener *)(arg1)->getLoadingListener();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceLoadingListener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.get_singleton

  call-seq:
    get_singleton -> ResourceGroupManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::ResourceGroupManager *) &Ogre::ResourceGroupManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceGroupManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceGroupManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> ResourceGroupManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ResourceGroupManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::ResourceGroupManager *)Ogre::ResourceGroupManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceGroupManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ScriptLoader

  Proxy of C++ Ogre::ScriptLoader class


*/
swig_class SwigClassScriptLoader;

SWIGINTERN void
free_Ogre_ScriptLoader(Ogre::ScriptLoader *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ScriptLoader.get_script_patterns

  call-seq:
    get_script_patterns -> StringVector

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptLoader_get_script_patterns(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);
  {
    try {
      result = (Ogre::StringVector *) &((Ogre::ScriptLoader const *)arg1)->getScriptPatterns();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptLoader.parse_script

  call-seq:
    parse_script(DataStreamPtr stream, String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptLoader_parse_script(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;
  }
  {
    try {
      (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::ScriptLoader.get_loading_order

  call-seq:
    get_loading_order -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptLoader_get_loading_order(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ScriptLoader const *)arg1)->getLoadingOrder();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ResourcePool

  Proxy of C++ Ogre::ResourcePool class


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


/*
  Document-method: Ogre::ResourcePool.new

  call-seq:
    ResourcePool.new(String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (ResourcePool *)new ResourcePool((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::ResourcePool.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourcePool_get_name(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);
  {
    try {
      result = (Ogre::String *) &((ResourcePool const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ResourceManager < Ogre::Ogre::ScriptLoader

  Proxy of C++ Ogre::ResourceManager class


*/
swig_class SwigClassResourceManager;

SWIGINTERN void
free_Ogre_ResourceManager(Ogre::ResourceManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ResourceManager.create

  call-seq:
    create(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList createParams=0) -> ResourcePtr
    create(String name, String group, bool isManual=false, ManualResourceLoader loader=0) -> ResourcePtr
    create(String name, String group, bool isManual=false) -> ResourcePtr
    create(String name, String group) -> ResourcePtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
  }
  {
    try {
      result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ResourceManager.create_or_retrieve

  call-seq:
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList createParams=0) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group) -> ResourceCreateOrRetrieveResult

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_create_or_retrieve__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;
  }
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve(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_or_retrieve__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_or_retrieve__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_or_retrieve__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_or_retrieve__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "ResourceManager.create_or_retrieve", 
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult ResourceManager.create_or_retrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *createParams)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult ResourceManager.create_or_retrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult ResourceManager.create_or_retrieve(Ogre::String const &name, Ogre::String const &group, bool isManual)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult ResourceManager.create_or_retrieve(Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.set_memory_budget

  call-seq:
    set_memory_budget(size_t bytes)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_set_memory_budget(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);
  {
    try {
      (arg1)->setMemoryBudget(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.get_memory_budget

  call-seq:
    get_memory_budget -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_get_memory_budget(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);
  {
    try {
      result = ((Ogre::ResourceManager const *)arg1)->getMemoryBudget();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.get_memory_usage

  call-seq:
    get_memory_usage -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_get_memory_usage(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);
  {
    try {
      result = ((Ogre::ResourceManager const *)arg1)->getMemoryUsage();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.unload

  call-seq:
    unload(String name)
    unload(ResourceHandle handle)

An instance method.

*/
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;
  }
  {
    try {
      (arg1)->unload((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->unload(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::ResourceManager.unload_all

  call-seq:
    unload_all(bool reloadableOnly=true)
    unload_all

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_unload_all__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);
  {
    try {
      (arg1)->unloadAll(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_unload_all__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);
  {
    try {
      (arg1)->unloadAll();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_unload_all(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_unload_all__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_unload_all__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.unload_all", 
    "    void ResourceManager.unload_all(bool reloadableOnly)\n"
    "    void ResourceManager.unload_all()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.reload_all

  call-seq:
    reload_all(bool reloadableOnly=true)
    reload_all

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_reload_all__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);
  {
    try {
      (arg1)->reloadAll(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_reload_all__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);
  {
    try {
      (arg1)->reloadAll();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_reload_all(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_reload_all__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_reload_all__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.reload_all", 
    "    void ResourceManager.reload_all(bool reloadableOnly)\n"
    "    void ResourceManager.reload_all()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.unload_unreferenced_resources

  call-seq:
    unload_unreferenced_resources(bool reloadableOnly=true)
    unload_unreferenced_resources

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_unload_unreferenced_resources__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);
  {
    try {
      (arg1)->unloadUnreferencedResources(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_unload_unreferenced_resources__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);
  {
    try {
      (arg1)->unloadUnreferencedResources();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_unload_unreferenced_resources(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_unload_unreferenced_resources__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_unload_unreferenced_resources__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.unload_unreferenced_resources", 
    "    void ResourceManager.unload_unreferenced_resources(bool reloadableOnly)\n"
    "    void ResourceManager.unload_unreferenced_resources()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.reload_unreferenced_resources

  call-seq:
    reload_unreferenced_resources(bool reloadableOnly=true)
    reload_unreferenced_resources

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_reload_unreferenced_resources__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);
  {
    try {
      (arg1)->reloadUnreferencedResources(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_reload_unreferenced_resources__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);
  {
    try {
      (arg1)->reloadUnreferencedResources();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_reload_unreferenced_resources(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_reload_unreferenced_resources__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_reload_unreferenced_resources__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.reload_unreferenced_resources", 
    "    void ResourceManager.reload_unreferenced_resources(bool reloadableOnly)\n"
    "    void ResourceManager.reload_unreferenced_resources()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.remove

  call-seq:
    remove(ResourcePtr r)
    remove(String name)
    remove(ResourceHandle handle)

An instance method.

*/
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);
  {
    try {
      (arg1)->remove(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      (arg1)->remove((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->remove(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::ResourceManager.remove_all

  call-seq:
    remove_all

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_remove_all(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);
  {
    try {
      (arg1)->removeAll();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.remove_unreferenced_resources

  call-seq:
    remove_unreferenced_resources(bool reloadableOnly=true)
    remove_unreferenced_resources

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_remove_unreferenced_resources__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);
  {
    try {
      (arg1)->removeUnreferencedResources(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_remove_unreferenced_resources__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);
  {
    try {
      (arg1)->removeUnreferencedResources();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_remove_unreferenced_resources(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_remove_unreferenced_resources__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_remove_unreferenced_resources__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.remove_unreferenced_resources", 
    "    void ResourceManager.remove_unreferenced_resources(bool reloadableOnly)\n"
    "    void ResourceManager.remove_unreferenced_resources()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.get_by_name

  call-seq:
    get_by_name(String name, String groupName=AUTODETECT_RESOURCE_GROUP_NAME) -> ResourcePtr
    get_by_name(String name) -> ResourcePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_get_by_name__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;
  }
  {
    try {
      result = (arg1)->getByName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_by_name__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;
  }
  {
    try {
      result = (arg1)->getByName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_by_name(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_get_by_name__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_get_by_name__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceManager.get_by_name", 
    "    Ogre::ResourcePtr ResourceManager.get_by_name(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    Ogre::ResourcePtr ResourceManager.get_by_name(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.get_by_handle

  call-seq:
    get_by_handle(ResourceHandle handle) -> ResourcePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_get_by_handle(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);
  {
    try {
      result = (arg1)->getByHandle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.resource_exists

  call-seq:
    resource_exists(String name) -> bool
    resource_exists(ResourceHandle handle) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_resource_exists__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;
  }
  {
    try {
      result = (bool)(arg1)->resourceExists((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_resource_exists__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);
  {
    try {
      result = (bool)(arg1)->resourceExists(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_resource_exists(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_resource_exists__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_resource_exists__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.resource_exists", 
    "    bool ResourceManager.resource_exists(Ogre::String const &name)\n"
    "    bool ResourceManager.resource_exists(Ogre::ResourceHandle handle)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager._notify_resource_touched

  call-seq:
    _notify_resource_touched(Resource res)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager__notify_resource_touched(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);
  {
    try {
      (arg1)->_notifyResourceTouched(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager._notify_resource_loaded

  call-seq:
    _notify_resource_loaded(Resource res)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager__notify_resource_loaded(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);
  {
    try {
      (arg1)->_notifyResourceLoaded(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager._notify_resource_unloaded

  call-seq:
    _notify_resource_unloaded(Resource res)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager__notify_resource_unloaded(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);
  {
    try {
      (arg1)->_notifyResourceUnloaded(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.prepare

  call-seq:
    prepare(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList loadParams=0, 
    bool backgroundThread=false) -> ResourcePtr
    prepare(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList loadParams=0) -> ResourcePtr
    prepare(String name, String group, bool isManual=false, ManualResourceLoader loader=0) -> ResourcePtr
    prepare(String name, String group, bool isManual=false) -> ResourcePtr
    prepare(String name, String group) -> ResourcePtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
  }
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ResourceManager.load

  call-seq:
    load(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList loadParams=0, 
    bool backgroundThread=false) -> ResourcePtr
    load(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList loadParams=0) -> ResourcePtr
    load(String name, String group, bool isManual=false, ManualResourceLoader loader=0) -> ResourcePtr
    load(String name, String group, bool isManual=false) -> ResourcePtr
    load(String name, String group) -> ResourcePtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
  }
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ResourceManager.get_script_patterns

  call-seq:
    get_script_patterns -> StringVector

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_get_script_patterns(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);
  {
    try {
      result = (Ogre::StringVector *) &((Ogre::ResourceManager const *)arg1)->getScriptPatterns();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.parse_script

  call-seq:
    parse_script(DataStreamPtr stream, String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_parse_script(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;
  }
  {
    try {
      (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.get_loading_order

  call-seq:
    get_loading_order -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_get_loading_order(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ResourceManager const *)arg1)->getLoadingOrder();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.get_resource_type

  call-seq:
    get_resource_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_get_resource_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ResourceManager const *)arg1)->getResourceType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.set_verbose

  call-seq:
    set_verbose(bool v)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_set_verbose(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);
  {
    try {
      (arg1)->setVerbose(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.get_verbose

  call-seq:
    get_verbose -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_get_verbose(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);
  {
    try {
      result = (bool)(arg1)->getVerbose();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.get_resource_pool

  call-seq:
    get_resource_pool(String name) -> ResourcePool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_get_resource_pool(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;
  }
  {
    try {
      result = (Ogre::ResourceManager::ResourcePool *)(arg1)->getResourcePool((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceManager__ResourcePool, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.destroy_resource_pool

  call-seq:
    destroy_resource_pool(ResourcePool pool)
    destroy_resource_pool(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_destroy_resource_pool__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);
  {
    try {
      (arg1)->destroyResourcePool(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_destroy_resource_pool__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;
  }
  {
    try {
      (arg1)->destroyResourcePool((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_destroy_resource_pool(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_destroy_resource_pool__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_destroy_resource_pool__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.destroy_resource_pool", 
    "    void ResourceManager.destroy_resource_pool(Ogre::ResourceManager::ResourcePool *pool)\n"
    "    void ResourceManager.destroy_resource_pool(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.destroy_all_resource_pools

  call-seq:
    destroy_all_resource_pools

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_destroy_all_resource_pools(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);
  {
    try {
      (arg1)->destroyAllResourcePools();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceManager.get_resource_iterator

  call-seq:
    get_resource_iterator -> ResourceMapIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceManager_get_resource_iterator(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);
  {
    try {
      result = (arg1)->getResourceIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceMapIterator(static_cast< const Ogre::ResourceManager::ResourceMapIterator& >(result))), SWIGTYPE_p_Ogre__ResourceManager__ResourceMapIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ArchiveManager

  Proxy of C++ Ogre::ArchiveManager class


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


/*
  Document-method: Ogre::ArchiveManager.new

  call-seq:
    ArchiveManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ArchiveManager *)new Ogre::ArchiveManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ArchiveManager(Ogre::ArchiveManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ArchiveManager.load

  call-seq:
    load(String filename, String archiveType) -> Archive

An instance method.

*/
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;
  }
  {
    try {
      result = (Ogre::Archive *)(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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;
}



/*
  Document-method: Ogre::ArchiveManager.unload

  call-seq:
    unload(Archive arch)
    unload(String filename)

An instance method.

*/
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);
  {
    try {
      (arg1)->unload(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      (arg1)->unload((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


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



/*
  Document-method: Ogre::ArchiveManager.get_archive_iterator

  call-seq:
    get_archive_iterator -> ArchiveMapIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ArchiveManager_get_archive_iterator(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);
  {
    try {
      result = (arg1)->getArchiveIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ArchiveManager.add_archive_factory

  call-seq:
    add_archive_factory(ArchiveFactory factory)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ArchiveManager_add_archive_factory(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);
  {
    try {
      (arg1)->addArchiveFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ArchiveManager.get_singleton

  call-seq:
    get_singleton -> ArchiveManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ArchiveManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::ArchiveManager *) &Ogre::ArchiveManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ArchiveManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ArchiveManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> ArchiveManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ArchiveManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::ArchiveManager *)Ogre::ArchiveManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ArchiveManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RenderQueue

  Proxy of C++ Ogre::RenderQueue class


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


/*
  Document-method: Ogre::RenderQueue.new

  call-seq:
    RenderQueue.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderQueue *)new Ogre::RenderQueue();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_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);
  {
    try {
      (arg1)->clear(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::RenderQueue.get_queue_group

  call-seq:
    get_queue_group(uint8 qid) -> RenderQueueGroup

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_get_queue_group(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);
  {
    try {
      result = (Ogre::RenderQueueGroup *)(arg1)->getQueueGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueueGroup, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.add_renderable

  call-seq:
    add_renderable(Renderable pRend, uint8 groupID, ushort priority)
    add_renderable(Renderable pRend, uint8 groupId)
    add_renderable(Renderable pRend)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_add_renderable__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);
  {
    try {
      (arg1)->addRenderable(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_add_renderable__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);
  {
    try {
      (arg1)->addRenderable(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_add_renderable__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);
  {
    try {
      (arg1)->addRenderable(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderQueue_add_renderable(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_add_renderable__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_add_renderable__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_add_renderable__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderQueue.add_renderable", 
    "    void RenderQueue.add_renderable(Ogre::Renderable *pRend, Ogre::uint8 groupID, Ogre::ushort priority)\n"
    "    void RenderQueue.add_renderable(Ogre::Renderable *pRend, Ogre::uint8 groupId)\n"
    "    void RenderQueue.add_renderable(Ogre::Renderable *pRend)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.get_default_queue_group

  call-seq:
    get_default_queue_group -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_get_default_queue_group(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::RenderQueue const *)arg1)->getDefaultQueueGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.set_default_renderable_priority

  call-seq:
    set_default_renderable_priority(ushort priority)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_set_default_renderable_priority(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);
  {
    try {
      (arg1)->setDefaultRenderablePriority(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.get_default_renderable_priority

  call-seq:
    get_default_renderable_priority -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_get_default_renderable_priority(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderQueue const *)arg1)->getDefaultRenderablePriority();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.set_default_queue_group

  call-seq:
    set_default_queue_group(uint8 grp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_set_default_queue_group(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);
  {
    try {
      (arg1)->setDefaultQueueGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue._get_queue_group_iterator

  call-seq:
    _get_queue_group_iterator -> QueueGroupIterator
    _get_queue_group_iterator -> ConstQueueGroupIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue__get_queue_group_iterator__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);
  {
    try {
      result = (arg1)->_getQueueGroupIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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__get_queue_group_iterator__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);
  {
    try {
      result = ((Ogre::RenderQueue const *)arg1)->_getQueueGroupIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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__get_queue_group_iterator(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__get_queue_group_iterator__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__get_queue_group_iterator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "RenderQueue._get_queue_group_iterator", 
    "    Ogre::RenderQueue::ConstQueueGroupIterator RenderQueue._get_queue_group_iterator()\n"
    "    Ogre::RenderQueue::ConstQueueGroupIterator RenderQueue._get_queue_group_iterator()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.set_split_passes_by_lighting_type

  call-seq:
    set_split_passes_by_lighting_type(bool split)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_set_split_passes_by_lighting_type(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);
  {
    try {
      (arg1)->setSplitPassesByLightingType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.get_split_passes_by_lighting_type

  call-seq:
    get_split_passes_by_lighting_type -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_get_split_passes_by_lighting_type(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);
  {
    try {
      result = (bool)((Ogre::RenderQueue const *)arg1)->getSplitPassesByLightingType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.set_split_no_shadow_passes

  call-seq:
    set_split_no_shadow_passes(bool split)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_set_split_no_shadow_passes(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);
  {
    try {
      (arg1)->setSplitNoShadowPasses(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.get_split_no_shadow_passes

  call-seq:
    get_split_no_shadow_passes -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_get_split_no_shadow_passes(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);
  {
    try {
      result = (bool)((Ogre::RenderQueue const *)arg1)->getSplitNoShadowPasses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.set_shadow_casters_cannot_be_receivers

  call-seq:
    set_shadow_casters_cannot_be_receivers(bool ind)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_set_shadow_casters_cannot_be_receivers(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);
  {
    try {
      (arg1)->setShadowCastersCannotBeReceivers(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.get_shadow_casters_cannot_be_receivers

  call-seq:
    get_shadow_casters_cannot_be_receivers -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_get_shadow_casters_cannot_be_receivers(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);
  {
    try {
      result = (bool)((Ogre::RenderQueue const *)arg1)->getShadowCastersCannotBeReceivers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.set_renderable_listener

  call-seq:
    set_renderable_listener(RenderableListener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_set_renderable_listener(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);
  {
    try {
      (arg1)->setRenderableListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.get_renderable_listener

  call-seq:
    get_renderable_listener -> RenderableListener

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_get_renderable_listener(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);
  {
    try {
      result = (Ogre::RenderQueue::RenderableListener *)((Ogre::RenderQueue const *)arg1)->getRenderableListener();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueue__RenderableListener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.merge

  call-seq:
    merge(RenderQueue rhs)

An instance method.

*/
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);
  {
    try {
      (arg1)->merge((Ogre::RenderQueue const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueue.process_visible_object

  call-seq:
    process_visible_object(MovableObject mo, Camera cam, bool onlyShadowCasters, 
    VisibleObjectsBoundsInfo visibleBounds)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueue_process_visible_object(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);
  {
    try {
      (arg1)->processVisibleObject(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::AxisAlignedBox

  Proxy of C++ Ogre::AxisAlignedBox class


*/
swig_class SwigClassAxisAlignedBox;


/*
  Document-method: Ogre::Extent.EXTENT_NULL

  call-seq:
    EXTENT_NULL -> int

A class method.

*/

/*
  Document-method: Ogre::Extent.EXTENT_FINITE

  call-seq:
    EXTENT_FINITE -> int

A class method.

*/

/*
  Document-method: Ogre::Extent.EXTENT_INFINITE

  call-seq:
    EXTENT_INFINITE -> int

A class method.

*/

/*
  Document-method: Ogre::CornerEnum.FAR_LEFT_BOTTOM

  call-seq:
    FAR_LEFT_BOTTOM -> int

A class method.

*/

/*
  Document-method: Ogre::CornerEnum.FAR_LEFT_TOP

  call-seq:
    FAR_LEFT_TOP -> int

A class method.

*/

/*
  Document-method: Ogre::CornerEnum.FAR_RIGHT_TOP

  call-seq:
    FAR_RIGHT_TOP -> int

A class method.

*/

/*
  Document-method: Ogre::CornerEnum.FAR_RIGHT_BOTTOM

  call-seq:
    FAR_RIGHT_BOTTOM -> int

A class method.

*/

/*
  Document-method: Ogre::CornerEnum.NEAR_RIGHT_BOTTOM

  call-seq:
    NEAR_RIGHT_BOTTOM -> int

A class method.

*/

/*
  Document-method: Ogre::CornerEnum.NEAR_LEFT_BOTTOM

  call-seq:
    NEAR_LEFT_BOTTOM -> int

A class method.

*/

/*
  Document-method: Ogre::CornerEnum.NEAR_LEFT_TOP

  call-seq:
    NEAR_LEFT_TOP -> int

A class method.

*/

/*
  Document-method: Ogre::CornerEnum.NEAR_RIGHT_TOP

  call-seq:
    NEAR_RIGHT_TOP -> int

A class method.

*/

/*
  Document-method: Ogre::AxisAlignedBox.new

  call-seq:
    AxisAlignedBox.new
    AxisAlignedBox.new(Extent e)
    AxisAlignedBox.new(AxisAlignedBox rkBox)
    AxisAlignedBox.new(Vector3 min, Vector3 max)
    AxisAlignedBox.new(Real mx, Real my, Real mz, Real Mx, Real My, Real Mz)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::AxisAlignedBox *)new Ogre::AxisAlignedBox();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::AxisAlignedBox *)new Ogre::AxisAlignedBox(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::AxisAlignedBox *)new Ogre::AxisAlignedBox((Ogre::AxisAlignedBox const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::AxisAlignedBox *)new Ogre::AxisAlignedBox((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::AxisAlignedBox *)new Ogre::AxisAlignedBox(arg1,arg2,arg3,arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::AxisAlignedBox.get_minimum

  call-seq:
    get_minimum -> Vector3
    get_minimum -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_get_minimum__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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::AxisAlignedBox const *)arg1)->getMinimum();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_get_minimum__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);
  {
    try {
      result = (Ogre::Vector3 *) &(arg1)->getMinimum();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_get_minimum(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_get_minimum__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_get_minimum__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "AxisAlignedBox.get_minimum", 
    "    Ogre::Vector3 & AxisAlignedBox.get_minimum()\n"
    "    Ogre::Vector3 & AxisAlignedBox.get_minimum()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.get_maximum

  call-seq:
    get_maximum -> Vector3
    get_maximum -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_get_maximum__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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::AxisAlignedBox const *)arg1)->getMaximum();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_get_maximum__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);
  {
    try {
      result = (Ogre::Vector3 *) &(arg1)->getMaximum();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_get_maximum(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_get_maximum__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_get_maximum__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "AxisAlignedBox.get_maximum", 
    "    Ogre::Vector3 & AxisAlignedBox.get_maximum()\n"
    "    Ogre::Vector3 & AxisAlignedBox.get_maximum()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.set_minimum

  call-seq:
    set_minimum(Vector3 vec)
    set_minimum(Real x, Real y, Real z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_minimum__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);
  {
    try {
      (arg1)->setMinimum((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_minimum__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);
  {
    try {
      (arg1)->setMinimum(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_set_minimum(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_set_minimum__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_set_minimum__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "AxisAlignedBox.set_minimum", 
    "    void AxisAlignedBox.set_minimum(Ogre::Vector3 const &vec)\n"
    "    void AxisAlignedBox.set_minimum(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.set_minimum_x

  call-seq:
    set_minimum_x(Real x)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_minimum_x(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);
  {
    try {
      (arg1)->setMinimumX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.set_minimum_y

  call-seq:
    set_minimum_y(Real y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_minimum_y(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);
  {
    try {
      (arg1)->setMinimumY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.set_minimum_z

  call-seq:
    set_minimum_z(Real z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_minimum_z(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);
  {
    try {
      (arg1)->setMinimumZ(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.set_maximum

  call-seq:
    set_maximum(Vector3 vec)
    set_maximum(Real x, Real y, Real z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_maximum__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);
  {
    try {
      (arg1)->setMaximum((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_maximum__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);
  {
    try {
      (arg1)->setMaximum(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_set_maximum(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_set_maximum__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_set_maximum__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "AxisAlignedBox.set_maximum", 
    "    void AxisAlignedBox.set_maximum(Ogre::Vector3 const &vec)\n"
    "    void AxisAlignedBox.set_maximum(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.set_maximum_x

  call-seq:
    set_maximum_x(Real x)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_maximum_x(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);
  {
    try {
      (arg1)->setMaximumX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.set_maximum_y

  call-seq:
    set_maximum_y(Real y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_maximum_y(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);
  {
    try {
      (arg1)->setMaximumY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.set_maximum_z

  call-seq:
    set_maximum_z(Real z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_maximum_z(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);
  {
    try {
      (arg1)->setMaximumZ(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.set_extents

  call-seq:
    set_extents(Vector3 min, Vector3 max)
    set_extents(Real mx, Real my, Real mz, Real Mx, Real My, Real Mz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_extents__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);
  {
    try {
      (arg1)->setExtents((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_extents__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);
  {
    try {
      (arg1)->setExtents(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_set_extents(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_set_extents__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_set_extents__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "AxisAlignedBox.set_extents", 
    "    void AxisAlignedBox.set_extents(Ogre::Vector3 const &min, Ogre::Vector3 const &max)\n"
    "    void AxisAlignedBox.set_extents(Ogre::Real mx, Ogre::Real my, Ogre::Real mz, Ogre::Real Mx, Ogre::Real My, Ogre::Real Mz)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.get_all_corners

  call-seq:
    get_all_corners -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_get_all_corners(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);
  {
    try {
      result = (Ogre::Vector3 *)((Ogre::AxisAlignedBox const *)arg1)->getAllCorners();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.get_corner

  call-seq:
    get_corner(CornerEnum cornerToGet) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_get_corner(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);
  {
    try {
      result = ((Ogre::AxisAlignedBox const *)arg1)->getCorner(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.merge

  call-seq:
    merge(AxisAlignedBox rhs)
    merge(Vector3 point)

An instance method.

*/
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);
  {
    try {
      (arg1)->merge((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->merge((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::AxisAlignedBox.transform

  call-seq:
    transform(Matrix4 matrix)

An instance method.

*/
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);
  {
    try {
      (arg1)->transform((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.transform_affine

  call-seq:
    transform_affine(Matrix4 m)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_transform_affine(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);
  {
    try {
      (arg1)->transformAffine((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.set_null

  call-seq:
    set_null

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_null(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);
  {
    try {
      (arg1)->setNull();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.is_null

  call-seq:
    is_null -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_is_null(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);
  {
    try {
      result = (bool)((Ogre::AxisAlignedBox const *)arg1)->isNull();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.is_finite

  call-seq:
    is_finite -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_is_finite(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);
  {
    try {
      result = (bool)((Ogre::AxisAlignedBox const *)arg1)->isFinite();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.set_infinite

  call-seq:
    set_infinite

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_set_infinite(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);
  {
    try {
      (arg1)->setInfinite();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.is_infinite

  call-seq:
    is_infinite -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_is_infinite(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);
  {
    try {
      result = (bool)((Ogre::AxisAlignedBox const *)arg1)->isInfinite();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.intersects

  call-seq:
    intersects(AxisAlignedBox b2) -> bool
    intersects(Sphere s) -> bool
    intersects(Plane p) -> bool
    intersects(Vector3 v) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::AxisAlignedBox const *)arg1)->intersects((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.intersection

  call-seq:
    intersection(AxisAlignedBox b2) -> AxisAlignedBox

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::AxisAlignedBox const *)arg1)->intersection((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::AxisAlignedBox(static_cast< const Ogre::AxisAlignedBox& >(result))), SWIGTYPE_p_Ogre__AxisAlignedBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.volume

  call-seq:
    volume -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)((Ogre::AxisAlignedBox const *)arg1)->volume();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.scale

  call-seq:
    scale(Vector3 s)

An instance method.

*/
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);
  {
    try {
      (arg1)->scale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.intersects

  call-seq:
    intersects(AxisAlignedBox b2) -> bool
    intersects(Sphere s) -> bool
    intersects(Plane p) -> bool
    intersects(Vector3 v) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::AxisAlignedBox const *)arg1)->intersects((Ogre::Sphere const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (bool)((Ogre::AxisAlignedBox const *)arg1)->intersects((Ogre::Plane const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (bool)((Ogre::AxisAlignedBox const *)arg1)->intersects((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::AxisAlignedBox.get_center

  call-seq:
    get_center -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_get_center(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);
  {
    try {
      result = ((Ogre::AxisAlignedBox const *)arg1)->getCenter();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.get_size

  call-seq:
    get_size -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_get_size(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);
  {
    try {
      result = ((Ogre::AxisAlignedBox const *)arg1)->getSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.get_half_size

  call-seq:
    get_half_size -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox_get_half_size(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);
  {
    try {
      result = ((Ogre::AxisAlignedBox const *)arg1)->getHalfSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.contains

  call-seq:
    contains(Vector3 v) -> bool
    contains(AxisAlignedBox other) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::AxisAlignedBox const *)arg1)->contains((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.distance

  call-seq:
    distance(Vector3 v) -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)((Ogre::AxisAlignedBox const *)arg1)->distance((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.contains

  call-seq:
    contains(Vector3 v) -> bool
    contains(AxisAlignedBox other) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::AxisAlignedBox const *)arg1)->contains((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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);
  {
    try {
      result = (bool)((Ogre::AxisAlignedBox const *)arg1)->operator ==((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.BOX_NULL

  call-seq:
    BOX_NULL -> AxisAlignedBox

Get value of attribute.

*/

/*
  Document-method: Ogre::AxisAlignedBox.AxisAlignedBox_BOX_NULL

  call-seq:
    AxisAlignedBox_BOX_NULL -> AxisAlignedBox

Get value of attribute.

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



/*
  Document-method: Ogre::AxisAlignedBox.BOX_INFINITE

  call-seq:
    BOX_INFINITE -> AxisAlignedBox

Get value of attribute.

*/

/*
  Document-method: Ogre::AxisAlignedBox.AxisAlignedBox_BOX_INFINITE

  call-seq:
    AxisAlignedBox_BOX_INFINITE -> AxisAlignedBox

Get value of attribute.

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



/*
  Document-class: Ogre::Sphere

  Proxy of C++ Ogre::Sphere class


*/
swig_class SwigClassSphere;


/*
  Document-method: Ogre::Sphere.new

  call-seq:
    Sphere.new
    Sphere.new(Vector3 center, Real radius)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Sphere *)new Ogre::Sphere();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Sphere *)new Ogre::Sphere((Ogre::Vector3 const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::Sphere.get_radius

  call-seq:
    get_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Sphere_get_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Sphere const *)arg1)->getRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Sphere.set_radius

  call-seq:
    set_radius(Real radius)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Sphere_set_radius(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);
  {
    try {
      (arg1)->setRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Sphere.get_center

  call-seq:
    get_center -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Sphere_get_center(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Sphere const *)arg1)->getCenter();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Sphere.set_center

  call-seq:
    set_center(Vector3 center)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Sphere_set_center(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);
  {
    try {
      (arg1)->setCenter((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Sphere.intersects

  call-seq:
    intersects(Sphere s) -> bool
    intersects(AxisAlignedBox box) -> bool
    intersects(Plane plane) -> bool
    intersects(Vector3 v) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::Sphere const *)arg1)->intersects((Ogre::Sphere const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (bool)((Ogre::Sphere const *)arg1)->intersects((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (bool)((Ogre::Sphere const *)arg1)->intersects((Ogre::Plane const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (bool)((Ogre::Sphere const *)arg1)->intersects((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::Sphere.merge

  call-seq:
    merge(Sphere oth)

An instance method.

*/
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);
  {
    try {
      (arg1)->merge((Ogre::Sphere const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Sphere(Ogre::Sphere *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::HardwareIndexBuffer < Ogre::Ogre::HardwareBuffer

  Proxy of C++ Ogre::HardwareIndexBuffer class


*/
swig_class SwigClassHardwareIndexBuffer;


/*
  Document-method: Ogre::IndexType.IT_16BIT

  call-seq:
    IT_16BIT -> int

A class method.

*/

/*
  Document-method: Ogre::IndexType.IT_32BIT

  call-seq:
    IT_32BIT -> int

A class method.

*/
SWIGINTERN void
free_Ogre_HardwareIndexBuffer(Ogre::HardwareIndexBuffer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::HardwareIndexBuffer.get_manager

  call-seq:
    get_manager -> HardwareBufferManagerBase

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareIndexBuffer_get_manager(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);
  {
    try {
      result = (Ogre::HardwareBufferManagerBase *)((Ogre::HardwareIndexBuffer const *)arg1)->getManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareIndexBuffer.get_type

  call-seq:
    get_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareIndexBuffer_get_type(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);
  {
    try {
      result = (Ogre::HardwareIndexBuffer::IndexType)((Ogre::HardwareIndexBuffer const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareIndexBuffer.get_num_indexes

  call-seq:
    get_num_indexes -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareIndexBuffer_get_num_indexes(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);
  {
    try {
      result = ((Ogre::HardwareIndexBuffer const *)arg1)->getNumIndexes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareIndexBuffer.get_index_size

  call-seq:
    get_index_size -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareIndexBuffer_get_index_size(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);
  {
    try {
      result = ((Ogre::HardwareIndexBuffer const *)arg1)->getIndexSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::HardwareIndexBufferSharedPtr

  Proxy of C++ Ogre::HardwareIndexBufferSharedPtr class


*/
swig_class SwigClassHardwareIndexBufferSharedPtr;


/*
  Document-method: Ogre::HardwareIndexBufferSharedPtr.new

  call-seq:
    HardwareIndexBufferSharedPtr.new
    HardwareIndexBufferSharedPtr.new(HardwareIndexBuffer buf)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::HardwareIndexBufferSharedPtr *)new Ogre::HardwareIndexBufferSharedPtr();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::HardwareIndexBufferSharedPtr *)new Ogre::HardwareIndexBufferSharedPtr(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::VertexData

  Proxy of C++ Ogre::VertexData class


*/
swig_class SwigClassVertexData;


/*
  Document-method: Ogre::VertexData.new

  call-seq:
    VertexData.new(HardwareBufferManagerBase mgr=0)
    VertexData.new
    VertexData.new(VertexDeclaration dcl, VertexBufferBinding bind)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::VertexData *)new Ogre::VertexData(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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;
  }
  {
    try {
      result = (Ogre::VertexData *)new Ogre::VertexData();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::VertexData *)new Ogre::VertexData(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::VertexData.vertexDeclaration

  call-seq:
    vertexDeclaration -> VertexDeclaration

Get value of attribute.

*/

/*
  Document-method: Ogre::VertexData.vertexDeclaration=

  call-seq:
    vertexDeclaration=(x) -> VertexDeclaration

Set new value for attribute.

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



/*
  Document-method: Ogre::VertexData.vertexBufferBinding

  call-seq:
    vertexBufferBinding -> VertexBufferBinding

Get value of attribute.

*/

/*
  Document-method: Ogre::VertexData.vertexBufferBinding=

  call-seq:
    vertexBufferBinding=(x) -> VertexBufferBinding

Set new value for attribute.

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



/*
  Document-method: Ogre::VertexData.mDeleteDclBinding

  call-seq:
    mDeleteDclBinding -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::VertexData.mDeleteDclBinding=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::VertexData.vertexStart

  call-seq:
    vertexStart -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::VertexData.vertexStart=

  call-seq:
    vertexStart=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::VertexData.vertexCount

  call-seq:
    vertexCount -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::VertexData.vertexCount=

  call-seq:
    vertexCount=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::VertexData.hwAnimationDataList

  call-seq:
    hwAnimationDataList -> HardwareAnimationDataList

Get value of attribute.

*/

/*
  Document-method: Ogre::VertexData.hwAnimationDataList=

  call-seq:
    hwAnimationDataList=(x) -> HardwareAnimationDataList

Set new value for attribute.

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



/*
  Document-method: Ogre::VertexData.hwAnimDataItemsUsed

  call-seq:
    hwAnimDataItemsUsed -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::VertexData.hwAnimDataItemsUsed=

  call-seq:
    hwAnimDataItemsUsed=(x) -> size_t

Set new value for attribute.

*/
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);
  {
    try {
      result = (Ogre::VertexData *)((Ogre::VertexData const *)arg1)->clone(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::VertexData *)((Ogre::VertexData const *)arg1)->clone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      result = (Ogre::VertexData *)((Ogre::VertexData const *)arg1)->clone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::VertexData.prepare_for_shadow_volume

  call-seq:
    prepare_for_shadow_volume

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexData_prepare_for_shadow_volume(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);
  {
    try {
      (arg1)->prepareForShadowVolume();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexData.hardwareShadowVolWBuffer

  call-seq:
    hardwareShadowVolWBuffer -> HardwareVertexBufferSharedPtr

Get value of attribute.

*/

/*
  Document-method: Ogre::VertexData.hardwareShadowVolWBuffer=

  call-seq:
    hardwareShadowVolWBuffer=(x) -> HardwareVertexBufferSharedPtr

Set new value for attribute.

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



/*
  Document-method: Ogre::VertexData.reorganise_buffers

  call-seq:
    reorganise_buffers(VertexDeclaration newDeclaration, BufferUsageList bufferUsage, 
    HardwareBufferManagerBase mgr=0)
    reorganise_buffers(VertexDeclaration newDeclaration, BufferUsageList bufferUsage)
    reorganise_buffers(VertexDeclaration newDeclaration, HardwareBufferManagerBase mgr=0)
    reorganise_buffers(VertexDeclaration newDeclaration)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexData_reorganise_buffers__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);
  {
    try {
      (arg1)->reorganiseBuffers(arg2,(Ogre::BufferUsageList const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_reorganise_buffers__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);
  {
    try {
      (arg1)->reorganiseBuffers(arg2,(Ogre::BufferUsageList const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_reorganise_buffers__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);
  {
    try {
      (arg1)->reorganiseBuffers(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_reorganise_buffers__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);
  {
    try {
      (arg1)->reorganiseBuffers(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexData_reorganise_buffers(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_reorganise_buffers__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_reorganise_buffers__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_reorganise_buffers__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_reorganise_buffers__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "VertexData.reorganise_buffers", 
    "    void VertexData.reorganise_buffers(Ogre::VertexDeclaration *newDeclaration, Ogre::BufferUsageList const &bufferUsage, Ogre::HardwareBufferManagerBase *mgr)\n"
    "    void VertexData.reorganise_buffers(Ogre::VertexDeclaration *newDeclaration, Ogre::BufferUsageList const &bufferUsage)\n"
    "    void VertexData.reorganise_buffers(Ogre::VertexDeclaration *newDeclaration, Ogre::HardwareBufferManagerBase *mgr)\n"
    "    void VertexData.reorganise_buffers(Ogre::VertexDeclaration *newDeclaration)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::VertexData.close_gaps_in_bindings

  call-seq:
    close_gaps_in_bindings

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexData_close_gaps_in_bindings(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);
  {
    try {
      (arg1)->closeGapsInBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexData.remove_unused_buffers

  call-seq:
    remove_unused_buffers

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexData_remove_unused_buffers(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);
  {
    try {
      (arg1)->removeUnusedBuffers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexData.convert_packed_colour

  call-seq:
    convert_packed_colour(VertexElementType srcType, VertexElementType destType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexData_convert_packed_colour(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);
  {
    try {
      (arg1)->convertPackedColour(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexData.allocate_hardware_animation_elements

  call-seq:
    allocate_hardware_animation_elements(ushort count, bool animateNormals) -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexData_allocate_hardware_animation_elements(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);
  {
    try {
      result = (Ogre::ushort)(arg1)->allocateHardwareAnimationElements(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::IndexData

  Proxy of C++ Ogre::IndexData class


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


/*
  Document-method: Ogre::IndexData.new

  call-seq:
    IndexData.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::IndexData *)new Ogre::IndexData();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::IndexData.indexBuffer

  call-seq:
    indexBuffer -> HardwareIndexBufferSharedPtr

Get value of attribute.

*/

/*
  Document-method: Ogre::IndexData.indexBuffer=

  call-seq:
    indexBuffer=(x) -> HardwareIndexBufferSharedPtr

Set new value for attribute.

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



/*
  Document-method: Ogre::IndexData.indexStart

  call-seq:
    indexStart -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::IndexData.indexStart=

  call-seq:
    indexStart=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::IndexData.indexCount

  call-seq:
    indexCount -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::IndexData.indexCount=

  call-seq:
    indexCount=(x) -> size_t

Set new value for attribute.

*/
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);
  {
    try {
      result = (Ogre::IndexData *)((Ogre::IndexData const *)arg1)->clone(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::IndexData *)((Ogre::IndexData const *)arg1)->clone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      result = (Ogre::IndexData *)((Ogre::IndexData const *)arg1)->clone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::IndexData.optimise_vertex_cache_tri_list

  call-seq:
    optimise_vertex_cache_tri_list

An instance method.

*/
SWIGINTERN VALUE
_wrap_IndexData_optimise_vertex_cache_tri_list(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);
  {
    try {
      (arg1)->optimiseVertexCacheTriList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::VertexCacheProfiler

  Proxy of C++ Ogre::VertexCacheProfiler class


*/
swig_class SwigClassVertexCacheProfiler;


/*
  Document-method: Ogre::CacheType.FIFO

  call-seq:
    FIFO -> int

A class method.

*/

/*
  Document-method: Ogre::CacheType.LRU

  call-seq:
    LRU -> int

A class method.

*/

/*
  Document-method: Ogre::VertexCacheProfiler.new

  call-seq:
    VertexCacheProfiler.new(unsigned int cachesize=16, CacheType cachetype=FIFO)
    VertexCacheProfiler.new(unsigned int cachesize=16)
    VertexCacheProfiler.new

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::VertexCacheProfiler *)new Ogre::VertexCacheProfiler(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::VertexCacheProfiler *)new Ogre::VertexCacheProfiler(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      result = (Ogre::VertexCacheProfiler *)new Ogre::VertexCacheProfiler();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::VertexCacheProfiler.profile

  call-seq:
    profile(HardwareIndexBufferSharedPtr indexBuffer)

An instance method.

*/
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);
  {
    try {
      (arg1)->profile((Ogre::HardwareIndexBufferSharedPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexCacheProfiler.reset

  call-seq:
    reset

An instance method.

*/
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);
  {
    try {
      (arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexCacheProfiler.flush

  call-seq:
    flush

An instance method.

*/
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);
  {
    try {
      (arg1)->flush();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexCacheProfiler.get_hits

  call-seq:
    get_hits -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexCacheProfiler_get_hits(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);
  {
    try {
      result = (unsigned int)(arg1)->getHits();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexCacheProfiler.get_misses

  call-seq:
    get_misses -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexCacheProfiler_get_misses(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);
  {
    try {
      result = (unsigned int)(arg1)->getMisses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexCacheProfiler.get_size

  call-seq:
    get_size -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_VertexCacheProfiler_get_size(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);
  {
    try {
      result = (unsigned int)(arg1)->getSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RenderOperation

  Proxy of C++ Ogre::RenderOperation class


*/
swig_class SwigClassRenderOperation;


/*
  Document-method: Ogre::OperationType.OT_POINT_LIST

  call-seq:
    OT_POINT_LIST -> int

A class method.

*/

/*
  Document-method: Ogre::OperationType.OT_LINE_LIST

  call-seq:
    OT_LINE_LIST -> int

A class method.

*/

/*
  Document-method: Ogre::OperationType.OT_LINE_STRIP

  call-seq:
    OT_LINE_STRIP -> int

A class method.

*/

/*
  Document-method: Ogre::OperationType.OT_TRIANGLE_LIST

  call-seq:
    OT_TRIANGLE_LIST -> int

A class method.

*/

/*
  Document-method: Ogre::OperationType.OT_TRIANGLE_STRIP

  call-seq:
    OT_TRIANGLE_STRIP -> int

A class method.

*/

/*
  Document-method: Ogre::OperationType.OT_TRIANGLE_FAN

  call-seq:
    OT_TRIANGLE_FAN -> int

A class method.

*/

/*
  Document-method: Ogre::RenderOperation.vertexData

  call-seq:
    vertexData -> VertexData

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderOperation.vertexData=

  call-seq:
    vertexData=(x) -> VertexData

Set new value for attribute.

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



/*
  Document-method: Ogre::RenderOperation.operationType

  call-seq:
    operationType -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderOperation.operationType=

  call-seq:
    operationType=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::RenderOperation.useIndexes

  call-seq:
    useIndexes -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderOperation.useIndexes=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::RenderOperation.indexData

  call-seq:
    indexData -> IndexData

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderOperation.indexData=

  call-seq:
    indexData=(x) -> IndexData

Set new value for attribute.

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



/*
  Document-method: Ogre::RenderOperation.srcRenderable

  call-seq:
    srcRenderable -> Renderable

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderOperation.srcRenderable=

  call-seq:
    srcRenderable=(x) -> Renderable

Set new value for attribute.

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



/*
  Document-method: Ogre::RenderOperation.numberOfInstances

  call-seq:
    numberOfInstances -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderOperation.numberOfInstances=

  call-seq:
    numberOfInstances=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::RenderOperation.useGlobalInstancingVertexBufferIsAvailable

  call-seq:
    useGlobalInstancingVertexBufferIsAvailable -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderOperation.useGlobalInstancingVertexBufferIsAvailable=

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

Set new value for attribute.

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


/*
  Document-method: Ogre::RenderOperation.new

  call-seq:
    RenderOperation.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderOperation *)new Ogre::RenderOperation();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderOperation(Ogre::RenderOperation *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::LayerBlendModeEx

  Proxy of C++ Ogre::LayerBlendModeEx class


*/
swig_class SwigClassLayerBlendModeEx;


/*
  Document-method: Ogre::LayerBlendModeEx.blendType

  call-seq:
    blendType -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::LayerBlendModeEx.blendType=

  call-seq:
    blendType=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::LayerBlendModeEx.operation

  call-seq:
    operation -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::LayerBlendModeEx.operation=

  call-seq:
    operation=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::LayerBlendModeEx.source1

  call-seq:
    source1 -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::LayerBlendModeEx.source1=

  call-seq:
    source1=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::LayerBlendModeEx.source2

  call-seq:
    source2 -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::LayerBlendModeEx.source2=

  call-seq:
    source2=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::LayerBlendModeEx.colourArg1

  call-seq:
    colourArg1 -> ColourValue

Get value of attribute.

*/

/*
  Document-method: Ogre::LayerBlendModeEx.colourArg1=

  call-seq:
    colourArg1=(x) -> ColourValue

Set new value for attribute.

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



/*
  Document-method: Ogre::LayerBlendModeEx.colourArg2

  call-seq:
    colourArg2 -> ColourValue

Get value of attribute.

*/

/*
  Document-method: Ogre::LayerBlendModeEx.colourArg2=

  call-seq:
    colourArg2=(x) -> ColourValue

Set new value for attribute.

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



/*
  Document-method: Ogre::LayerBlendModeEx.alphaArg1

  call-seq:
    alphaArg1 -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::LayerBlendModeEx.alphaArg1=

  call-seq:
    alphaArg1=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::LayerBlendModeEx.alphaArg2

  call-seq:
    alphaArg2 -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::LayerBlendModeEx.alphaArg2=

  call-seq:
    alphaArg2=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::LayerBlendModeEx.factor

  call-seq:
    factor -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::LayerBlendModeEx.factor=

  call-seq:
    factor=(x) -> Real

Set new value for attribute.

*/
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);
  {
    try {
      result = (bool)((Ogre::LayerBlendModeEx const *)arg1)->operator ==((Ogre::LayerBlendModeEx const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::LayerBlendModeEx.new

  call-seq:
    LayerBlendModeEx.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::LayerBlendModeEx *)new Ogre::LayerBlendModeEx();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_LayerBlendModeEx(Ogre::LayerBlendModeEx *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::MaterialSharedPtr

  Proxy of C++ Ogre::MaterialSharedPtr class


*/
swig_class SwigClassMaterialSharedPtr;


/*
  Document-method: Ogre::MaterialSharedPtr.new

  call-seq:
    MaterialSharedPtr.new
    MaterialSharedPtr.new(MaterialSharedPtr r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SharedPtr< Ogre::Material > *)new Ogre::SharedPtr< Ogre::Material >();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::SharedPtr< Ogre::Material > *)new Ogre::SharedPtr< Ogre::Material >((Ogre::SharedPtr< Ogre::Material > const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::MaterialSharedPtr.__ref__

  call-seq:
    __ref__ -> Material

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Material *) &((Ogre::SharedPtr< Ogre::Material > const *)arg1)->operator *();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSharedPtr.__deref__

  call-seq:
    __deref__ -> Material

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Material *)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->operator ->();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSharedPtr.get

  call-seq:
    get -> Material

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Material *)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->get();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSharedPtr.bind

  call-seq:
    bind(Material rep, SharedPtrFreeMethod inFreeMethod=SPFM_DELETE)
    bind(Material rep)

An instance method.

*/
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);
  {
    try {
      (arg1)->bind(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->bind(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::MaterialSharedPtr.unique

  call-seq:
    unique -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->unique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSharedPtr.use_count

  call-seq:
    use_count -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_use_count(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);
  {
    try {
      result = (unsigned int)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->useCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSharedPtr.use_count_pointer

  call-seq:
    use_count_pointer -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_use_count_pointer(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);
  {
    try {
      result = (unsigned int *)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->useCountPointer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSharedPtr.get_pointer

  call-seq:
    get_pointer -> Material

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_pointer(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);
  {
    try {
      result = (Ogre::Material *)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->getPointer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSharedPtr.free_method

  call-seq:
    free_method -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_free_method(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);
  {
    try {
      result = (Ogre::SharedPtrFreeMethod)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->freeMethod();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSharedPtr.is_null

  call-seq:
    is_null -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_is_null(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);
  {
    try {
      result = (bool)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->isNull();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSharedPtr.set_null

  call-seq:
    set_null

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_null(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);
  {
    try {
      (arg1)->setNull();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.is_transparent

  call-seq:
    is_transparent -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_is_transparent(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);
  {
    try {
      result = (bool)(*arg1)->isTransparent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_receive_shadows

  call-seq:
    set_receive_shadows(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_receive_shadows(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);
  {
    try {
      (*arg1)->setReceiveShadows(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_receive_shadows

  call-seq:
    get_receive_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_receive_shadows(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);
  {
    try {
      result = (bool)(*arg1)->getReceiveShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_transparency_casts_shadows

  call-seq:
    set_transparency_casts_shadows(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_transparency_casts_shadows(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);
  {
    try {
      (*arg1)->setTransparencyCastsShadows(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_transparency_casts_shadows

  call-seq:
    get_transparency_casts_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_transparency_casts_shadows(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);
  {
    try {
      result = (bool)(*arg1)->getTransparencyCastsShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.create_technique

  call-seq:
    create_technique -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_create_technique(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);
  {
    try {
      result = (Ogre::Technique *)(*arg1)->createTechnique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_technique

  call-seq:
    get_technique(unsigned short index) -> Technique
    get_technique(String name) -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_technique__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);
  {
    try {
      result = (Ogre::Technique *)(*arg1)->getTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_technique__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;
  }
  {
    try {
      result = (Ogre::Technique *)(*arg1)->getTechnique((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_technique(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_get_technique__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_get_technique__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Material.get_technique", 
    "    Ogre::Technique * Material.get_technique(unsigned short index)\n"
    "    Ogre::Technique * Material.get_technique(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_num_techniques

  call-seq:
    get_num_techniques -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_num_techniques(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);
  {
    try {
      result = (unsigned short)(*arg1)->getNumTechniques();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.remove_technique

  call-seq:
    remove_technique(unsigned short index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_remove_technique(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);
  {
    try {
      (*arg1)->removeTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.remove_all_techniques

  call-seq:
    remove_all_techniques

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_remove_all_techniques(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);
  {
    try {
      (*arg1)->removeAllTechniques();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_technique_iterator

  call-seq:
    get_technique_iterator -> TechniqueIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_technique_iterator(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);
  {
    try {
      result = (*arg1)->getTechniqueIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Material.get_supported_technique_iterator

  call-seq:
    get_supported_technique_iterator -> TechniqueIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_supported_technique_iterator(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);
  {
    try {
      result = (*arg1)->getSupportedTechniqueIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Material.get_supported_technique

  call-seq:
    get_supported_technique(unsigned short index) -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_supported_technique(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);
  {
    try {
      result = (Ogre::Technique *)(*arg1)->getSupportedTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_num_supported_techniques

  call-seq:
    get_num_supported_techniques -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_num_supported_techniques(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);
  {
    try {
      result = (unsigned short)(*arg1)->getNumSupportedTechniques();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_unsupported_techniques_explanation

  call-seq:
    get_unsupported_techniques_explanation -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_unsupported_techniques_explanation(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);
  {
    try {
      result = (Ogre::String *) &(*arg1)->getUnsupportedTechniquesExplanation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_num_lod_levels

  call-seq:
    get_num_lod_levels(unsigned short schemeIndex) -> unsigned short
    get_num_lod_levels(String schemeName) -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_num_lod_levels__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);
  {
    try {
      result = (unsigned short)(*arg1)->getNumLodLevels(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_num_lod_levels__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;
  }
  {
    try {
      result = (unsigned short)(*arg1)->getNumLodLevels((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_get_num_lod_levels(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_get_num_lod_levels__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_get_num_lod_levels__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Material.get_num_lod_levels", 
    "    unsigned short Material.get_num_lod_levels(unsigned short schemeIndex)\n"
    "    unsigned short Material.get_num_lod_levels(Ogre::String const &schemeName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_best_technique

  call-seq:
    get_best_technique(unsigned short lodIndex=0, Renderable rend=0) -> Technique
    get_best_technique(unsigned short lodIndex=0) -> Technique
    get_best_technique -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_best_technique__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);
  {
    try {
      result = (Ogre::Technique *)(*arg1)->getBestTechnique(arg2,(Ogre::Renderable const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_best_technique__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);
  {
    try {
      result = (Ogre::Technique *)(*arg1)->getBestTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_best_technique__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);
  {
    try {
      result = (Ogre::Technique *)(*arg1)->getBestTechnique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_get_best_technique(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_get_best_technique__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_get_best_technique__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_get_best_technique__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Material.get_best_technique", 
    "    Ogre::Technique * Material.get_best_technique(unsigned short lodIndex, Ogre::Renderable const *rend)\n"
    "    Ogre::Technique * Material.get_best_technique(unsigned short lodIndex)\n"
    "    Ogre::Technique * Material.get_best_technique()\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;
  }
  {
    try {
      result = (*arg1)->clone((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = (*arg1)->clone((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
  }
  {
    try {
      result = (*arg1)->clone((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Material.copy_details_to

  call-seq:
    copy_details_to(MaterialPtr mat)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_copy_details_to(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);
  {
    try {
      (*arg1)->copyDetailsTo(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.compile

  call-seq:
    compile(bool autoManageTextureUnits=true)
    compile

An instance method.

*/
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);
  {
    try {
      (*arg1)->compile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (*arg1)->compile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Material.set_point_size

  call-seq:
    set_point_size(Real ps)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_point_size(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);
  {
    try {
      (*arg1)->setPointSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_ambient

  call-seq:
    set_ambient(Real red, Real green, Real blue)
    set_ambient(ColourValue ambient)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_ambient__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);
  {
    try {
      (*arg1)->setAmbient(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_ambient__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);
  {
    try {
      (*arg1)->setAmbient((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_set_ambient(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_set_ambient__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_set_ambient__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Material.set_ambient", 
    "    void Material.set_ambient(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Material.set_ambient(Ogre::ColourValue const &ambient)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_diffuse

  call-seq:
    set_diffuse(Real red, Real green, Real blue, Real alpha)
    set_diffuse(ColourValue diffuse)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_diffuse__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);
  {
    try {
      (*arg1)->setDiffuse(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_diffuse__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);
  {
    try {
      (*arg1)->setDiffuse((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_set_diffuse(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_set_diffuse__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_set_diffuse__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.set_diffuse", 
    "    void Material.set_diffuse(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Material.set_diffuse(Ogre::ColourValue const &diffuse)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_specular

  call-seq:
    set_specular(Real red, Real green, Real blue, Real alpha)
    set_specular(ColourValue specular)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_specular__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);
  {
    try {
      (*arg1)->setSpecular(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_specular__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);
  {
    try {
      (*arg1)->setSpecular((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_set_specular(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_set_specular__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_set_specular__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.set_specular", 
    "    void Material.set_specular(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Material.set_specular(Ogre::ColourValue const &specular)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_shininess

  call-seq:
    set_shininess(Real val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_shininess(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);
  {
    try {
      (*arg1)->setShininess(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_self_illumination

  call-seq:
    set_self_illumination(Real red, Real green, Real blue)
    set_self_illumination(ColourValue selfIllum)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_self_illumination__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);
  {
    try {
      (*arg1)->setSelfIllumination(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_self_illumination__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);
  {
    try {
      (*arg1)->setSelfIllumination((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_set_self_illumination(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_set_self_illumination__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_set_self_illumination__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Material.set_self_illumination", 
    "    void Material.set_self_illumination(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Material.set_self_illumination(Ogre::ColourValue const &selfIllum)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_depth_check_enabled

  call-seq:
    set_depth_check_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_depth_check_enabled(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);
  {
    try {
      (*arg1)->setDepthCheckEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_depth_write_enabled

  call-seq:
    set_depth_write_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_depth_write_enabled(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);
  {
    try {
      (*arg1)->setDepthWriteEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_depth_function

  call-seq:
    set_depth_function(CompareFunction func)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_depth_function(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);
  {
    try {
      (*arg1)->setDepthFunction(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_colour_write_enabled

  call-seq:
    set_colour_write_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_colour_write_enabled(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);
  {
    try {
      (*arg1)->setColourWriteEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_culling_mode

  call-seq:
    set_culling_mode(CullingMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_culling_mode(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);
  {
    try {
      (*arg1)->setCullingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_manual_culling_mode

  call-seq:
    set_manual_culling_mode(ManualCullingMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_manual_culling_mode(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);
  {
    try {
      (*arg1)->setManualCullingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_lighting_enabled

  call-seq:
    set_lighting_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_lighting_enabled(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);
  {
    try {
      (*arg1)->setLightingEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_shading_mode

  call-seq:
    set_shading_mode(ShadeOptions mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_shading_mode(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);
  {
    try {
      (*arg1)->setShadingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_fog

  call-seq:
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White, 
    Real expDensity=0.001, Real linearStart=0.0, 
    Real linearEnd=1.0)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White, 
    Real expDensity=0.001, Real linearStart=0.0)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White, 
    Real expDensity=0.001)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE)
    set_fog(bool overrideScene)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_fog__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);
  {
    try {
      (*arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_fog__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);
  {
    try {
      (*arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_fog__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);
  {
    try {
      (*arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_fog__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);
  {
    try {
      (*arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_fog__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);
  {
    try {
      (*arg1)->setFog(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_fog__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);
  {
    try {
      (*arg1)->setFog(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_set_fog(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_set_fog__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_set_fog__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_set_fog__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_set_fog__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_set_fog__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_set_fog__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Material.set_fog", 
    "    void Material.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart, Ogre::Real linearEnd)\n"
    "    void Material.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart)\n"
    "    void Material.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity)\n"
    "    void Material.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour)\n"
    "    void Material.set_fog(bool overrideScene, Ogre::FogMode mode)\n"
    "    void Material.set_fog(bool overrideScene)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_depth_bias

  call-seq:
    set_depth_bias(float constantBias, float slopeScaleBias)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_depth_bias(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);
  {
    try {
      (*arg1)->setDepthBias(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_texture_filtering

  call-seq:
    set_texture_filtering(TextureFilterOptions filterType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_texture_filtering(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);
  {
    try {
      (*arg1)->setTextureFiltering(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_texture_anisotropy

  call-seq:
    set_texture_anisotropy(int maxAniso)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_texture_anisotropy(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);
  {
    try {
      (*arg1)->setTextureAnisotropy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_scene_blending

  call-seq:
    set_scene_blending(SceneBlendType sbt)
    set_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_scene_blending__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);
  {
    try {
      (*arg1)->setSceneBlending(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_scene_blending__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);
  {
    try {
      (*arg1)->setSceneBlending(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_set_scene_blending(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_set_scene_blending__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_set_scene_blending__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Material.set_scene_blending", 
    "    void Material.set_scene_blending(Ogre::SceneBlendType const sbt)\n"
    "    void Material.set_scene_blending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_separate_scene_blending

  call-seq:
    set_separate_scene_blending(SceneBlendType sbt, SceneBlendType sbta)
    set_separate_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, 
    SceneBlendFactor sourceFactorAlpha, 
    SceneBlendFactor destFactorAlpha)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_separate_scene_blending__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);
  {
    try {
      (*arg1)->setSeparateSceneBlending(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_separate_scene_blending__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);
  {
    try {
      (*arg1)->setSeparateSceneBlending(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_set_separate_scene_blending(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_set_separate_scene_blending__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_set_separate_scene_blending__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.set_separate_scene_blending", 
    "    void Material.set_separate_scene_blending(Ogre::SceneBlendType const sbt, Ogre::SceneBlendType const sbta)\n"
    "    void Material.set_separate_scene_blending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor, Ogre::SceneBlendFactor const sourceFactorAlpha, Ogre::SceneBlendFactor const destFactorAlpha)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material._notify_needs_recompile

  call-seq:
    _notify_needs_recompile

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr__notify_needs_recompile(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);
  {
    try {
      (*arg1)->_notifyNeedsRecompile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_lod_levels

  call-seq:
    set_lod_levels(LodValueList lodValues)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_lod_levels(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);
  {
    try {
      (*arg1)->setLodLevels((Ogre::Material::LodValueList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_lod_value_iterator

  call-seq:
    get_lod_value_iterator -> LodValueIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_lod_value_iterator(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);
  {
    try {
      result = (*arg1)->getLodValueIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Material.get_user_lod_value_iterator

  call-seq:
    get_user_lod_value_iterator -> LodValueIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_user_lod_value_iterator(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);
  {
    try {
      result = (*arg1)->getUserLodValueIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Material.get_lod_index

  call-seq:
    get_lod_index(Real value) -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_lod_index(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);
  {
    try {
      result = (Ogre::ushort)(*arg1)->getLodIndex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_lod_strategy

  call-seq:
    get_lod_strategy -> LodStrategy

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_lod_strategy(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);
  {
    try {
      result = (Ogre::LodStrategy *)(*arg1)->getLodStrategy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_lod_strategy

  call-seq:
    set_lod_strategy(LodStrategy lodStrategy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_lod_strategy(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);
  {
    try {
      (*arg1)->setLodStrategy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.touch

  call-seq:
    touch

An instance method.

*/
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);
  {
    try {
      (*arg1)->touch();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.apply_texture_aliases

  call-seq:
    apply_texture_aliases(AliasTextureNamePairList aliasList, bool apply=true) -> bool
    apply_texture_aliases(AliasTextureNamePairList aliasList) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_apply_texture_aliases__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);
  {
    try {
      result = (bool)(*arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_apply_texture_aliases__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);
  {
    try {
      result = (bool)(*arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_apply_texture_aliases(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_apply_texture_aliases__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_apply_texture_aliases__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Material.apply_texture_aliases", 
    "    bool Material.apply_texture_aliases(Ogre::AliasTextureNamePairList const &aliasList, bool const apply)\n"
    "    bool Material.apply_texture_aliases(Ogre::AliasTextureNamePairList const &aliasList)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_compilation_required

  call-seq:
    get_compilation_required -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_compilation_required(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);
  {
    try {
      result = (bool)(*arg1)->getCompilationRequired();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.cast

  call-seq:
    cast(VALUE value) -> Material

An instance method.

*/
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];
  {
    try {
      result = (Ogre::Material *)Ogre_Material_cast(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.prepare

  call-seq:
    prepare(bool backgroundThread=false)
    prepare

An instance method.

*/
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);
  {
    try {
      (*arg1)->prepare(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (*arg1)->prepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Resource.load

  call-seq:
    load(bool backgroundThread=false)
    load

An instance method.

*/
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);
  {
    try {
      (*arg1)->load(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (*arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Resource.reload

  call-seq:
    reload

An instance method.

*/
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);
  {
    try {
      (*arg1)->reload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_reloadable

  call-seq:
    is_reloadable -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_is_reloadable(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);
  {
    try {
      result = (bool)(*arg1)->isReloadable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_manually_loaded

  call-seq:
    is_manually_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_is_manually_loaded(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);
  {
    try {
      result = (bool)(*arg1)->isManuallyLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (*arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_size

  call-seq:
    get_size -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_size(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);
  {
    try {
      result = (*arg1)->getSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_name(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);
  {
    try {
      result = (Ogre::String *) &(*arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_handle

  call-seq:
    get_handle -> ResourceHandle

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_handle(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);
  {
    try {
      result = (Ogre::ResourceHandle)(*arg1)->getHandle();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_prepared

  call-seq:
    is_prepared -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_is_prepared(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);
  {
    try {
      result = (bool)(*arg1)->isPrepared();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_loaded

  call-seq:
    is_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_is_loaded(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);
  {
    try {
      result = (bool)(*arg1)->isLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_loading

  call-seq:
    is_loading -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_is_loading(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);
  {
    try {
      result = (bool)(*arg1)->isLoading();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_loading_state

  call-seq:
    get_loading_state -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_loading_state(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);
  {
    try {
      result = (Ogre::Resource::LoadingState)(*arg1)->getLoadingState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_background_loaded

  call-seq:
    is_background_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_is_background_loaded(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);
  {
    try {
      result = (bool)(*arg1)->isBackgroundLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.set_background_loaded

  call-seq:
    set_background_loaded(bool bl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_background_loaded(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);
  {
    try {
      (*arg1)->setBackgroundLoaded(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.escalate_loading

  call-seq:
    escalate_loading

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_escalate_loading(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);
  {
    try {
      (*arg1)->escalateLoading();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.add_listener

  call-seq:
    add_listener(Listener lis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_add_listener(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);
  {
    try {
      (*arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.remove_listener

  call-seq:
    remove_listener(Listener lis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_remove_listener(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);
  {
    try {
      (*arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_group

  call-seq:
    get_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_group(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);
  {
    try {
      result = (Ogre::String *) &(*arg1)->getGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.change_group_ownership

  call-seq:
    change_group_ownership(String newGroup)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_change_group_ownership(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;
  }
  {
    try {
      (*arg1)->changeGroupOwnership((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_creator

  call-seq:
    get_creator -> ResourceManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_creator(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);
  {
    try {
      result = (Ogre::ResourceManager *)(*arg1)->getCreator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_origin

  call-seq:
    get_origin -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_origin(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);
  {
    try {
      result = (Ogre::String *) &(*arg1)->getOrigin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._notify_origin

  call-seq:
    _notify_origin(String origin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr__notify_origin(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;
  }
  {
    try {
      (*arg1)->_notifyOrigin((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_state_count

  call-seq:
    get_state_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_state_count(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);
  {
    try {
      result = (*arg1)->getStateCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._dirty_state

  call-seq:
    _dirty_state

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr__dirty_state(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);
  {
    try {
      (*arg1)->_dirtyState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._fire_loading_complete

  call-seq:
    _fire_loading_complete(bool wasBackgroundLoaded)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr__fire_loading_complete(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);
  {
    try {
      (*arg1)->_fireLoadingComplete(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._fire_preparing_complete

  call-seq:
    _fire_preparing_complete(bool wasBackgroundLoaded)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr__fire_preparing_complete(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);
  {
    try {
      (*arg1)->_firePreparingComplete(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._fire_unloading_complete

  call-seq:
    _fire_unloading_complete

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr__fire_unloading_complete(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);
  {
    try {
      (*arg1)->_fireUnloadingComplete();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.get_param_dictionary

  call-seq:
    get_param_dictionary -> ParamDictionary
    get_param_dictionary -> ParamDictionary

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_param_dictionary__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);
  {
    try {
      result = (Ogre::ParamDictionary *)(*arg1)->getParamDictionary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_param_dictionary__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);
  {
    try {
      result = (Ogre::ParamDictionary *)(*arg1)->getParamDictionary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_get_param_dictionary(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_get_param_dictionary__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_get_param_dictionary__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringInterface.get_param_dictionary", 
    "    Ogre::ParamDictionary const * StringInterface.get_param_dictionary()\n"
    "    Ogre::ParamDictionary const * StringInterface.get_param_dictionary()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.get_parameters

  call-seq:
    get_parameters -> ParameterList

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_parameters(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);
  {
    try {
      result = (Ogre::ParameterList *) &(*arg1)->getParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.set_parameter

  call-seq:
    set_parameter(String name, String value) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_parameter(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;
  }
  {
    try {
      result = (bool)(*arg1)->setParameter((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringInterface.set_parameter_list

  call-seq:
    set_parameter_list(NameValuePairList paramList)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_set_parameter_list(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);
  {
    try {
      (*arg1)->setParameterList((Ogre::NameValuePairList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.get_parameter

  call-seq:
    get_parameter(String name) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get_parameter(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;
  }
  {
    try {
      result = (*arg1)->getParameter((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringInterface.copy_parameters_to

  call-seq:
    copy_parameters_to(StringInterface dest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_copy_parameters_to(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);
  {
    try {
      (*arg1)->copyParametersTo(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.cleanup_dictionary

  call-seq:
    cleanup_dictionary

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_cleanup_dictionary(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);
  {
    try {
      (*arg1)->cleanupDictionary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Material < Ogre::Ogre::Resource

  Proxy of C++ Ogre::Material class


*/
swig_class SwigClassMaterial;


/*
  Document-method: Ogre::Material.new

  call-seq:
    Material.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual=false, 
    ManualResourceLoader loader=0)
    Material.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual=false)
    Material.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Material *)new Ogre::Material(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Material *)new Ogre::Material(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Material *)new Ogre::Material(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::Material.is_transparent

  call-seq:
    is_transparent -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_is_transparent(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);
  {
    try {
      result = (bool)((Ogre::Material const *)arg1)->isTransparent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_receive_shadows

  call-seq:
    set_receive_shadows(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_receive_shadows(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);
  {
    try {
      (arg1)->setReceiveShadows(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_receive_shadows

  call-seq:
    get_receive_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_receive_shadows(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);
  {
    try {
      result = (bool)((Ogre::Material const *)arg1)->getReceiveShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_transparency_casts_shadows

  call-seq:
    set_transparency_casts_shadows(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_transparency_casts_shadows(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);
  {
    try {
      (arg1)->setTransparencyCastsShadows(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_transparency_casts_shadows

  call-seq:
    get_transparency_casts_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_transparency_casts_shadows(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);
  {
    try {
      result = (bool)((Ogre::Material const *)arg1)->getTransparencyCastsShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.create_technique

  call-seq:
    create_technique -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_create_technique(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);
  {
    try {
      result = (Ogre::Technique *)(arg1)->createTechnique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_technique

  call-seq:
    get_technique(unsigned short index) -> Technique
    get_technique(String name) -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_technique__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);
  {
    try {
      result = (Ogre::Technique *)(arg1)->getTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_get_technique__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;
  }
  {
    try {
      result = (Ogre::Technique *)(arg1)->getTechnique((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_technique(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_get_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) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Material_get_technique__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Material.get_technique", 
    "    Ogre::Technique * Material.get_technique(unsigned short index)\n"
    "    Ogre::Technique * Material.get_technique(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_num_techniques

  call-seq:
    get_num_techniques -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_num_techniques(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);
  {
    try {
      result = (unsigned short)((Ogre::Material const *)arg1)->getNumTechniques();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.remove_technique

  call-seq:
    remove_technique(unsigned short index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_remove_technique(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);
  {
    try {
      (arg1)->removeTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.remove_all_techniques

  call-seq:
    remove_all_techniques

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_remove_all_techniques(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);
  {
    try {
      (arg1)->removeAllTechniques();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_technique_iterator

  call-seq:
    get_technique_iterator -> TechniqueIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_technique_iterator(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);
  {
    try {
      result = (arg1)->getTechniqueIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Material.get_supported_technique_iterator

  call-seq:
    get_supported_technique_iterator -> TechniqueIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_supported_technique_iterator(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);
  {
    try {
      result = (arg1)->getSupportedTechniqueIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Material.get_supported_technique

  call-seq:
    get_supported_technique(unsigned short index) -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_supported_technique(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);
  {
    try {
      result = (Ogre::Technique *)(arg1)->getSupportedTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_num_supported_techniques

  call-seq:
    get_num_supported_techniques -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_num_supported_techniques(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);
  {
    try {
      result = (unsigned short)((Ogre::Material const *)arg1)->getNumSupportedTechniques();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_unsupported_techniques_explanation

  call-seq:
    get_unsupported_techniques_explanation -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_unsupported_techniques_explanation(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Material const *)arg1)->getUnsupportedTechniquesExplanation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_num_lod_levels

  call-seq:
    get_num_lod_levels(unsigned short schemeIndex) -> unsigned short
    get_num_lod_levels(String schemeName) -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_num_lod_levels__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);
  {
    try {
      result = (unsigned short)((Ogre::Material const *)arg1)->getNumLodLevels(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_get_num_lod_levels__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;
  }
  {
    try {
      result = (unsigned short)((Ogre::Material const *)arg1)->getNumLodLevels((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_get_num_lod_levels(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_get_num_lod_levels__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_get_num_lod_levels__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Material.get_num_lod_levels", 
    "    unsigned short Material.get_num_lod_levels(unsigned short schemeIndex)\n"
    "    unsigned short Material.get_num_lod_levels(Ogre::String const &schemeName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_best_technique

  call-seq:
    get_best_technique(unsigned short lodIndex=0, Renderable rend=0) -> Technique
    get_best_technique(unsigned short lodIndex=0) -> Technique
    get_best_technique -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_best_technique__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);
  {
    try {
      result = (Ogre::Technique *)(arg1)->getBestTechnique(arg2,(Ogre::Renderable const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_get_best_technique__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);
  {
    try {
      result = (Ogre::Technique *)(arg1)->getBestTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_get_best_technique__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);
  {
    try {
      result = (Ogre::Technique *)(arg1)->getBestTechnique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_get_best_technique(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_get_best_technique__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_get_best_technique__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_get_best_technique__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Material.get_best_technique", 
    "    Ogre::Technique * Material.get_best_technique(unsigned short lodIndex, Ogre::Renderable const *rend)\n"
    "    Ogre::Technique * Material.get_best_technique(unsigned short lodIndex)\n"
    "    Ogre::Technique * Material.get_best_technique()\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_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;
  }
  {
    try {
      result = ((Ogre::Material const *)arg1)->clone((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = ((Ogre::Material const *)arg1)->clone((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
  }
  {
    try {
      result = ((Ogre::Material const *)arg1)->clone((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Material.copy_details_to

  call-seq:
    copy_details_to(MaterialPtr mat)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_copy_details_to(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);
  {
    try {
      ((Ogre::Material const *)arg1)->copyDetailsTo(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.compile

  call-seq:
    compile(bool autoManageTextureUnits=true)
    compile

An instance method.

*/
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);
  {
    try {
      (arg1)->compile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->compile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Material.set_point_size

  call-seq:
    set_point_size(Real ps)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_point_size(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);
  {
    try {
      (arg1)->setPointSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_ambient

  call-seq:
    set_ambient(Real red, Real green, Real blue)
    set_ambient(ColourValue ambient)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_ambient__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);
  {
    try {
      (arg1)->setAmbient(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_set_ambient__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);
  {
    try {
      (arg1)->setAmbient((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_set_ambient(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_set_ambient__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_set_ambient__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Material.set_ambient", 
    "    void Material.set_ambient(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Material.set_ambient(Ogre::ColourValue const &ambient)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_diffuse

  call-seq:
    set_diffuse(Real red, Real green, Real blue, Real alpha)
    set_diffuse(ColourValue diffuse)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_diffuse__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);
  {
    try {
      (arg1)->setDiffuse(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_set_diffuse__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);
  {
    try {
      (arg1)->setDiffuse((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_set_diffuse(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_set_diffuse__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_set_diffuse__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.set_diffuse", 
    "    void Material.set_diffuse(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Material.set_diffuse(Ogre::ColourValue const &diffuse)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_specular

  call-seq:
    set_specular(Real red, Real green, Real blue, Real alpha)
    set_specular(ColourValue specular)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_specular__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);
  {
    try {
      (arg1)->setSpecular(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_set_specular__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);
  {
    try {
      (arg1)->setSpecular((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_set_specular(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_set_specular__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_set_specular__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.set_specular", 
    "    void Material.set_specular(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Material.set_specular(Ogre::ColourValue const &specular)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_shininess

  call-seq:
    set_shininess(Real val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_shininess(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);
  {
    try {
      (arg1)->setShininess(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_self_illumination

  call-seq:
    set_self_illumination(Real red, Real green, Real blue)
    set_self_illumination(ColourValue selfIllum)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_self_illumination__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);
  {
    try {
      (arg1)->setSelfIllumination(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_set_self_illumination__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);
  {
    try {
      (arg1)->setSelfIllumination((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_set_self_illumination(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_set_self_illumination__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_set_self_illumination__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Material.set_self_illumination", 
    "    void Material.set_self_illumination(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Material.set_self_illumination(Ogre::ColourValue const &selfIllum)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_depth_check_enabled

  call-seq:
    set_depth_check_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_depth_check_enabled(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);
  {
    try {
      (arg1)->setDepthCheckEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_depth_write_enabled

  call-seq:
    set_depth_write_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_depth_write_enabled(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);
  {
    try {
      (arg1)->setDepthWriteEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_depth_function

  call-seq:
    set_depth_function(CompareFunction func)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_depth_function(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);
  {
    try {
      (arg1)->setDepthFunction(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_colour_write_enabled

  call-seq:
    set_colour_write_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_colour_write_enabled(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);
  {
    try {
      (arg1)->setColourWriteEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_culling_mode

  call-seq:
    set_culling_mode(CullingMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_culling_mode(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);
  {
    try {
      (arg1)->setCullingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_manual_culling_mode

  call-seq:
    set_manual_culling_mode(ManualCullingMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_manual_culling_mode(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);
  {
    try {
      (arg1)->setManualCullingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_lighting_enabled

  call-seq:
    set_lighting_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_lighting_enabled(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);
  {
    try {
      (arg1)->setLightingEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_shading_mode

  call-seq:
    set_shading_mode(ShadeOptions mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_shading_mode(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);
  {
    try {
      (arg1)->setShadingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_fog

  call-seq:
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White, 
    Real expDensity=0.001, Real linearStart=0.0, 
    Real linearEnd=1.0)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White, 
    Real expDensity=0.001, Real linearStart=0.0)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White, 
    Real expDensity=0.001)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE)
    set_fog(bool overrideScene)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_set_fog(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_set_fog__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_set_fog__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_set_fog__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_set_fog__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_set_fog__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_set_fog__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Material.set_fog", 
    "    void Material.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart, Ogre::Real linearEnd)\n"
    "    void Material.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart)\n"
    "    void Material.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity)\n"
    "    void Material.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour)\n"
    "    void Material.set_fog(bool overrideScene, Ogre::FogMode mode)\n"
    "    void Material.set_fog(bool overrideScene)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_depth_bias

  call-seq:
    set_depth_bias(float constantBias, float slopeScaleBias)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_depth_bias(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);
  {
    try {
      (arg1)->setDepthBias(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_texture_filtering

  call-seq:
    set_texture_filtering(TextureFilterOptions filterType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_texture_filtering(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);
  {
    try {
      (arg1)->setTextureFiltering(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_texture_anisotropy

  call-seq:
    set_texture_anisotropy(int maxAniso)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_texture_anisotropy(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);
  {
    try {
      (arg1)->setTextureAnisotropy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_scene_blending

  call-seq:
    set_scene_blending(SceneBlendType sbt)
    set_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_scene_blending__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);
  {
    try {
      (arg1)->setSceneBlending(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_separate_scene_blending

  call-seq:
    set_separate_scene_blending(SceneBlendType sbt, SceneBlendType sbta)
    set_separate_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, 
    SceneBlendFactor sourceFactorAlpha, 
    SceneBlendFactor destFactorAlpha)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_separate_scene_blending__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);
  {
    try {
      (arg1)->setSeparateSceneBlending(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_scene_blending

  call-seq:
    set_scene_blending(SceneBlendType sbt)
    set_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_scene_blending__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);
  {
    try {
      (arg1)->setSceneBlending(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_set_scene_blending(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_set_scene_blending__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_set_scene_blending__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Material.set_scene_blending", 
    "    void Material.set_scene_blending(Ogre::SceneBlendType const sbt)\n"
    "    void Material.set_scene_blending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_separate_scene_blending

  call-seq:
    set_separate_scene_blending(SceneBlendType sbt, SceneBlendType sbta)
    set_separate_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, 
    SceneBlendFactor sourceFactorAlpha, 
    SceneBlendFactor destFactorAlpha)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_separate_scene_blending__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);
  {
    try {
      (arg1)->setSeparateSceneBlending(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_set_separate_scene_blending(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_set_separate_scene_blending__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_set_separate_scene_blending__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.set_separate_scene_blending", 
    "    void Material.set_separate_scene_blending(Ogre::SceneBlendType const sbt, Ogre::SceneBlendType const sbta)\n"
    "    void Material.set_separate_scene_blending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor, Ogre::SceneBlendFactor const sourceFactorAlpha, Ogre::SceneBlendFactor const destFactorAlpha)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material._notify_needs_recompile

  call-seq:
    _notify_needs_recompile

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material__notify_needs_recompile(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);
  {
    try {
      (arg1)->_notifyNeedsRecompile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_lod_levels

  call-seq:
    set_lod_levels(LodValueList lodValues)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_lod_levels(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);
  {
    try {
      (arg1)->setLodLevels((Ogre::Material::LodValueList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_lod_value_iterator

  call-seq:
    get_lod_value_iterator -> LodValueIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_lod_value_iterator(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);
  {
    try {
      result = ((Ogre::Material const *)arg1)->getLodValueIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Material.get_user_lod_value_iterator

  call-seq:
    get_user_lod_value_iterator -> LodValueIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_user_lod_value_iterator(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);
  {
    try {
      result = ((Ogre::Material const *)arg1)->getUserLodValueIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Material.get_lod_index

  call-seq:
    get_lod_index(Real value) -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_lod_index(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::Material const *)arg1)->getLodIndex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_lod_strategy

  call-seq:
    get_lod_strategy -> LodStrategy

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_lod_strategy(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);
  {
    try {
      result = (Ogre::LodStrategy *)((Ogre::Material const *)arg1)->getLodStrategy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.set_lod_strategy

  call-seq:
    set_lod_strategy(LodStrategy lodStrategy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_set_lod_strategy(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);
  {
    try {
      (arg1)->setLodStrategy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.touch

  call-seq:
    touch

An instance method.

*/
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);
  {
    try {
      (arg1)->touch();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.apply_texture_aliases

  call-seq:
    apply_texture_aliases(AliasTextureNamePairList aliasList, bool apply=true) -> bool
    apply_texture_aliases(AliasTextureNamePairList aliasList) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_apply_texture_aliases__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);
  {
    try {
      result = (bool)((Ogre::Material const *)arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_apply_texture_aliases__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);
  {
    try {
      result = (bool)((Ogre::Material const *)arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_apply_texture_aliases(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_apply_texture_aliases__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_apply_texture_aliases__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Material.apply_texture_aliases", 
    "    bool Material.apply_texture_aliases(Ogre::AliasTextureNamePairList const &aliasList, bool const apply)\n"
    "    bool Material.apply_texture_aliases(Ogre::AliasTextureNamePairList const &aliasList)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.get_compilation_required

  call-seq:
    get_compilation_required -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Material_get_compilation_required(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);
  {
    try {
      result = (bool)((Ogre::Material const *)arg1)->getCompilationRequired();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Material.cast

  call-seq:
    cast(VALUE value) -> Material

A class method.

*/
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];
  {
    try {
      result = (Ogre::Material *)Ogre_Material_cast(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::MaterialPtr < Ogre::Ogre::MaterialSharedPtr

  Proxy of C++ Ogre::MaterialPtr class


*/
swig_class SwigClassMaterialPtr;


/*
  Document-method: Ogre::MaterialPtr.new

  call-seq:
    MaterialPtr.new
    MaterialPtr.new(Material rep)
    MaterialPtr.new(MaterialPtr r)
    MaterialPtr.new(ResourcePtr r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::MaterialPtr *)new Ogre::MaterialPtr();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MaterialPtr *)new Ogre::MaterialPtr(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MaterialPtr *)new Ogre::MaterialPtr((Ogre::MaterialPtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::MaterialPtr *)new Ogre::MaterialPtr((Ogre::ResourcePtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::Serializer

  Proxy of C++ Ogre::Serializer class


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


/*
  Document-method: Ogre::Serializer.new

  call-seq:
    Serializer.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Serializer *)new Ogre::Serializer();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Serializer(Ogre::Serializer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Endian.ENDIAN_NATIVE

  call-seq:
    ENDIAN_NATIVE -> int

A class method.

*/

/*
  Document-method: Ogre::Endian.ENDIAN_BIG

  call-seq:
    ENDIAN_BIG -> int

A class method.

*/

/*
  Document-method: Ogre::Endian.ENDIAN_LITTLE

  call-seq:
    ENDIAN_LITTLE -> int

A class method.

*/

/*
  Document-class: Ogre::GpuConstantDefinition

  Proxy of C++ Ogre::GpuConstantDefinition class


*/
swig_class SwigClassGpuConstantDefinition;


/*
  Document-method: Ogre::GpuConstantDefinition.constType

  call-seq:
    constType -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuConstantDefinition.constType=

  call-seq:
    constType=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::GpuConstantDefinition.physicalIndex

  call-seq:
    physicalIndex -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuConstantDefinition.physicalIndex=

  call-seq:
    physicalIndex=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::GpuConstantDefinition.logicalIndex

  call-seq:
    logicalIndex -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuConstantDefinition.logicalIndex=

  call-seq:
    logicalIndex=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::GpuConstantDefinition.elementSize

  call-seq:
    elementSize -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuConstantDefinition.elementSize=

  call-seq:
    elementSize=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::GpuConstantDefinition.arraySize

  call-seq:
    arraySize -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuConstantDefinition.arraySize=

  call-seq:
    arraySize=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::GpuConstantDefinition.variability

  call-seq:
    variability -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuConstantDefinition.variability=

  call-seq:
    variability=(x) -> uint16

Set new value for attribute.

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



/*
  Document-method: Ogre::GpuConstantDefinition.is_float

  call-seq:
    is_float -> bool
    is_float(GpuConstantType c) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuConstantDefinition_is_float__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);
  {
    try {
      result = (bool)((Ogre::GpuConstantDefinition const *)arg1)->isFloat();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuConstantDefinition.is_float

  call-seq:
    is_float -> bool
    is_float(GpuConstantType c) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_GpuConstantDefinition_is_float__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);
  {
    try {
      result = (bool)Ogre::GpuConstantDefinition::isFloat(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuConstantDefinition_is_float(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_is_float__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_is_float__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "GpuConstantDefinition.is_float", 
    "    bool GpuConstantDefinition.is_float(Ogre::GpuConstantDefinition const *self)\n"
    "    bool GpuConstantDefinition.is_float(Ogre::GpuConstantType c)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuConstantDefinition.is_sampler

  call-seq:
    is_sampler -> bool
    is_sampler(GpuConstantType c) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuConstantDefinition_is_sampler__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);
  {
    try {
      result = (bool)((Ogre::GpuConstantDefinition const *)arg1)->isSampler();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuConstantDefinition.is_sampler

  call-seq:
    is_sampler -> bool
    is_sampler(GpuConstantType c) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_GpuConstantDefinition_is_sampler__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);
  {
    try {
      result = (bool)Ogre::GpuConstantDefinition::isSampler(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuConstantDefinition_is_sampler(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_is_sampler__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_is_sampler__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "GpuConstantDefinition.is_sampler", 
    "    bool GpuConstantDefinition.is_sampler(Ogre::GpuConstantDefinition const *self)\n"
    "    bool GpuConstantDefinition.is_sampler(Ogre::GpuConstantType c)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuConstantDefinition.get_element_size

  call-seq:
    get_element_size(GpuConstantType ctype, bool padToMultiplesOf4) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_GpuConstantDefinition_get_element_size(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);
  {
    try {
      result = Ogre::GpuConstantDefinition::getElementSize(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
  }
  


/*
  Document-method: Ogre::GpuConstantDefinition.new

  call-seq:
    GpuConstantDefinition.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::GpuConstantDefinition *)new Ogre::GpuConstantDefinition();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuConstantDefinition(Ogre::GpuConstantDefinition *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::GpuNamedConstants

  Proxy of C++ Ogre::GpuNamedConstants class


*/
swig_class SwigClassGpuNamedConstants;


/*
  Document-method: Ogre::GpuNamedConstants.floatBufferSize

  call-seq:
    floatBufferSize -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuNamedConstants.floatBufferSize=

  call-seq:
    floatBufferSize=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::GpuNamedConstants.intBufferSize

  call-seq:
    intBufferSize -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuNamedConstants.intBufferSize=

  call-seq:
    intBufferSize=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::GpuNamedConstants.map

  call-seq:
    map -> GpuConstantDefinitionMap

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuNamedConstants.map=

  call-seq:
    map=(x) -> GpuConstantDefinitionMap

Set new value for attribute.

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


/*
  Document-method: Ogre::GpuNamedConstants.new

  call-seq:
    GpuNamedConstants.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::GpuNamedConstants *)new Ogre::GpuNamedConstants();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuNamedConstants.generate_constant_definition_array_entries

  call-seq:
    generate_constant_definition_array_entries(String paramName, GpuConstantDefinition baseDef)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuNamedConstants_generate_constant_definition_array_entries(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);
  {
    try {
      (arg1)->generateConstantDefinitionArrayEntries((Ogre::String const &)*arg2,(Ogre::GpuConstantDefinition const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuNamedConstants.get_generate_all_constant_definition_array_entries

  call-seq:
    get_generate_all_constant_definition_array_entries -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_GpuNamedConstants_get_generate_all_constant_definition_array_entries(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;
  }
  {
    try {
      result = (bool)Ogre::GpuNamedConstants::getGenerateAllConstantDefinitionArrayEntries();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuNamedConstants.set_generate_all_constant_definition_array_entries

  call-seq:
    set_generate_all_constant_definition_array_entries(bool generateAll)

A class method.

*/
SWIGINTERN VALUE
_wrap_GpuNamedConstants_set_generate_all_constant_definition_array_entries(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);
  {
    try {
      Ogre::GpuNamedConstants::setGenerateAllConstantDefinitionArrayEntries(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuNamedConstants.save

  call-seq:
    save(String filename)

An instance method.

*/
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;
  }
  {
    try {
      ((Ogre::GpuNamedConstants const *)arg1)->save((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuNamedConstants.load

  call-seq:
    load(DataStreamPtr stream)

An instance method.

*/
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);
  {
    try {
      (arg1)->load(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuNamedConstants(Ogre::GpuNamedConstants *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::GpuNamedConstantsSerializer < Ogre::Ogre::Serializer

  Proxy of C++ Ogre::GpuNamedConstantsSerializer class


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


/*
  Document-method: Ogre::GpuNamedConstantsSerializer.new

  call-seq:
    GpuNamedConstantsSerializer.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::GpuNamedConstantsSerializer *)new Ogre::GpuNamedConstantsSerializer();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuNamedConstantsSerializer(Ogre::GpuNamedConstantsSerializer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::GpuNamedConstantsSerializer.export_named_constants

  call-seq:
    export_named_constants(GpuNamedConstants pConsts, String filename, Endian endianMode=ENDIAN_NATIVE)
    export_named_constants(GpuNamedConstants pConsts, String filename)
    export_named_constants(GpuNamedConstants pConsts, DataStreamPtr stream, Endian endianMode=ENDIAN_NATIVE)
    export_named_constants(GpuNamedConstants pConsts, DataStreamPtr stream)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuNamedConstantsSerializer_export_named_constants__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);
  {
    try {
      (arg1)->exportNamedConstants((Ogre::GpuNamedConstants const *)arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstantsSerializer_export_named_constants__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;
  }
  {
    try {
      (arg1)->exportNamedConstants((Ogre::GpuNamedConstants const *)arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstantsSerializer_export_named_constants__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);
  {
    try {
      (arg1)->exportNamedConstants((Ogre::GpuNamedConstants const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstantsSerializer_export_named_constants__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));
    }
  }
  {
    try {
      (arg1)->exportNamedConstants((Ogre::GpuNamedConstants const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuNamedConstantsSerializer_export_named_constants(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_export_named_constants__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_export_named_constants__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_export_named_constants__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_export_named_constants__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuNamedConstantsSerializer.export_named_constants", 
    "    void GpuNamedConstantsSerializer.export_named_constants(Ogre::GpuNamedConstants const *pConsts, Ogre::String const &filename, Ogre::Serializer::Endian endianMode)\n"
    "    void GpuNamedConstantsSerializer.export_named_constants(Ogre::GpuNamedConstants const *pConsts, Ogre::String const &filename)\n"
    "    void GpuNamedConstantsSerializer.export_named_constants(Ogre::GpuNamedConstants const *pConsts, Ogre::DataStreamPtr stream, Ogre::Serializer::Endian endianMode)\n"
    "    void GpuNamedConstantsSerializer.export_named_constants(Ogre::GpuNamedConstants const *pConsts, Ogre::DataStreamPtr stream)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuNamedConstantsSerializer.import_named_constants

  call-seq:
    import_named_constants(DataStreamPtr stream, GpuNamedConstants pDest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuNamedConstantsSerializer_import_named_constants(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);
  {
    try {
      (arg1)->importNamedConstants(*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::GpuLogicalIndexUse

  Proxy of C++ Ogre::GpuLogicalIndexUse class


*/
swig_class SwigClassGpuLogicalIndexUse;


/*
  Document-method: Ogre::GpuLogicalIndexUse.physicalIndex

  call-seq:
    physicalIndex -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuLogicalIndexUse.physicalIndex=

  call-seq:
    physicalIndex=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::GpuLogicalIndexUse.currentSize

  call-seq:
    currentSize -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuLogicalIndexUse.currentSize=

  call-seq:
    currentSize=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::GpuLogicalIndexUse.variability

  call-seq:
    variability -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuLogicalIndexUse.variability=

  call-seq:
    variability=(x) -> uint16

Set new value for attribute.

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



/*
  Document-method: Ogre::GpuLogicalIndexUse.new

  call-seq:
    GpuLogicalIndexUse.new
    GpuLogicalIndexUse.new(size_t bufIdx, size_t curSz, uint16 v)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::GpuLogicalIndexUse *)new Ogre::GpuLogicalIndexUse();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::GpuLogicalIndexUse *)new Ogre::GpuLogicalIndexUse(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::GpuLogicalBufferStruct

  Proxy of C++ Ogre::GpuLogicalBufferStruct class


*/
swig_class SwigClassGpuLogicalBufferStruct;


/*
  Document-method: Ogre::GpuLogicalBufferStruct.map

  call-seq:
    map -> GpuLogicalIndexUseMap

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuLogicalBufferStruct.map=

  call-seq:
    map=(x) -> GpuLogicalIndexUseMap

Set new value for attribute.

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



/*
  Document-method: Ogre::GpuLogicalBufferStruct.bufferSize

  call-seq:
    bufferSize -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::GpuLogicalBufferStruct.bufferSize=

  call-seq:
    bufferSize=(x) -> size_t

Set new value for attribute.

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


/*
  Document-method: Ogre::GpuLogicalBufferStruct.new

  call-seq:
    GpuLogicalBufferStruct.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::GpuLogicalBufferStruct *)new Ogre::GpuLogicalBufferStruct();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuLogicalBufferStruct(Ogre::GpuLogicalBufferStruct *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::GpuSharedParameters

  Proxy of C++ Ogre::GpuSharedParameters class


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


/*
  Document-method: Ogre::GpuSharedParameters.new

  call-seq:
    GpuSharedParameters.new(String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::GpuSharedParameters *)new Ogre::GpuSharedParameters((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::GpuSharedParameters.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters_get_name(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);
  {
    try {
      result = (Ogre::String *) &(arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters.add_constant_definition

  call-seq:
    add_constant_definition(String name, GpuConstantType constType, size_t arraySize=1)
    add_constant_definition(String name, GpuConstantType constType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters_add_constant_definition__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);
  {
    try {
      (arg1)->addConstantDefinition((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_add_constant_definition__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);
  {
    try {
      (arg1)->addConstantDefinition((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuSharedParameters_add_constant_definition(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_add_constant_definition__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_add_constant_definition__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuSharedParameters.add_constant_definition", 
    "    void GpuSharedParameters.add_constant_definition(Ogre::String const &name, Ogre::GpuConstantType constType, size_t arraySize)\n"
    "    void GpuSharedParameters.add_constant_definition(Ogre::String const &name, Ogre::GpuConstantType constType)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters.remove_constant_definition

  call-seq:
    remove_constant_definition(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters_remove_constant_definition(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;
  }
  {
    try {
      (arg1)->removeConstantDefinition((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters.remove_all_constant_definitions

  call-seq:
    remove_all_constant_definitions

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters_remove_all_constant_definitions(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);
  {
    try {
      (arg1)->removeAllConstantDefinitions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters.get_version

  call-seq:
    get_version -> unsigned long

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters_get_version(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);
  {
    try {
      result = (unsigned long)((Ogre::GpuSharedParameters const *)arg1)->getVersion();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters._mark_dirty

  call-seq:
    _mark_dirty

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters__mark_dirty(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);
  {
    try {
      (arg1)->_markDirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters.get_frame_last_updated

  call-seq:
    get_frame_last_updated -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters_get_frame_last_updated(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);
  {
    try {
      result = ((Ogre::GpuSharedParameters const *)arg1)->getFrameLastUpdated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters.get_constant_definition_iterator

  call-seq:
    get_constant_definition_iterator -> GpuConstantDefinitionIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters_get_constant_definition_iterator(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);
  {
    try {
      result = ((Ogre::GpuSharedParameters const *)arg1)->getConstantDefinitionIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::GpuSharedParameters.get_constant_definition

  call-seq:
    get_constant_definition(String name) -> GpuConstantDefinition

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters_get_constant_definition(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;
  }
  {
    try {
      result = (Ogre::GpuConstantDefinition *) &((Ogre::GpuSharedParameters const *)arg1)->getConstantDefinition((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuConstantDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters.get_constant_definitions

  call-seq:
    get_constant_definitions -> GpuNamedConstants

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters_get_constant_definitions(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);
  {
    try {
      result = (Ogre::GpuNamedConstants *) &((Ogre::GpuSharedParameters const *)arg1)->getConstantDefinitions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters.set_named_constant

  call-seq:
    set_named_constant(String name, Real val)
    set_named_constant(String name, int val)
    set_named_constant(String name, Vector4 vec)
    set_named_constant(String name, Vector3 vec)
    set_named_constant(String name, Matrix4 m)
    set_named_constant(String name, Matrix4 m, size_t numEntries)
    set_named_constant(String name, float val, size_t count)
    set_named_constant(String name, double val, size_t count)
    set_named_constant(String name, ColourValue colour)
    set_named_constant(String name, int val, size_t count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Vector4 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Matrix4 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Matrix4 const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(float const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(double const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(int const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuSharedParameters_set_named_constant(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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__SWIG_9(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuSharedParameters.set_named_constant", 
    "    void GpuSharedParameters.set_named_constant(Ogre::String const &name, Ogre::Real val)\n"
    "    void GpuSharedParameters.set_named_constant(Ogre::String const &name, int val)\n"
    "    void GpuSharedParameters.set_named_constant(Ogre::String const &name, Ogre::Vector4 const &vec)\n"
    "    void GpuSharedParameters.set_named_constant(Ogre::String const &name, Ogre::Vector3 const &vec)\n"
    "    void GpuSharedParameters.set_named_constant(Ogre::String const &name, Ogre::Matrix4 const &m)\n"
    "    void GpuSharedParameters.set_named_constant(Ogre::String const &name, Ogre::Matrix4 const *m, size_t numEntries)\n"
    "    void GpuSharedParameters.set_named_constant(Ogre::String const &name, float const *val, size_t count)\n"
    "    void GpuSharedParameters.set_named_constant(Ogre::String const &name, double const *val, size_t count)\n"
    "    void GpuSharedParameters.set_named_constant(Ogre::String const &name, Ogre::ColourValue const &colour)\n"
    "    void GpuSharedParameters.set_named_constant(Ogre::String const &name, int const *val, size_t count)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters.get_float_pointer

  call-seq:
    get_float_pointer(size_t pos) -> float
    get_float_pointer(size_t pos) -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters_get_float_pointer__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);
  {
    try {
      result = (float *)(arg1)->getFloatPointer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_get_float_pointer__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);
  {
    try {
      result = (float *)((Ogre::GpuSharedParameters const *)arg1)->getFloatPointer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuSharedParameters_get_float_pointer(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_get_float_pointer__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_get_float_pointer__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "GpuSharedParameters.get_float_pointer", 
    "    float const * GpuSharedParameters.get_float_pointer(size_t pos)\n"
    "    float const * GpuSharedParameters.get_float_pointer(size_t pos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters.get_int_pointer

  call-seq:
    get_int_pointer(size_t pos) -> int
    get_int_pointer(size_t pos) -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters_get_int_pointer__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);
  {
    try {
      result = (int *)(arg1)->getIntPointer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_get_int_pointer__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);
  {
    try {
      result = (int *)((Ogre::GpuSharedParameters const *)arg1)->getIntPointer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuSharedParameters_get_int_pointer(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_get_int_pointer__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_get_int_pointer__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "GpuSharedParameters.get_int_pointer", 
    "    int const * GpuSharedParameters.get_int_pointer(size_t pos)\n"
    "    int const * GpuSharedParameters.get_int_pointer(size_t pos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters._set_render_system_data

  call-seq:
    _set_render_system_data(Any data)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters__set_render_system_data(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);
  {
    try {
      ((Ogre::GpuSharedParameters const *)arg1)->_setRenderSystemData((Ogre::Any const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParameters._get_render_system_data

  call-seq:
    _get_render_system_data -> Any

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParameters__get_render_system_data(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);
  {
    try {
      result = (Ogre::Any *) &((Ogre::GpuSharedParameters const *)arg1)->_getRenderSystemData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::GpuSharedParametersUsage

  Proxy of C++ Ogre::GpuSharedParametersUsage class


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


/*
  Document-method: Ogre::GpuSharedParametersUsage.new

  call-seq:
    GpuSharedParametersUsage.new(GpuSharedParametersPtr sharedParams, GpuProgramParameters params)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::GpuSharedParametersUsage *)new Ogre::GpuSharedParametersUsage(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParametersUsage._copy_shared_params_to_target_params

  call-seq:
    _copy_shared_params_to_target_params

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParametersUsage__copy_shared_params_to_target_params(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);
  {
    try {
      (arg1)->_copySharedParamsToTargetParams();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParametersUsage.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParametersUsage_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::GpuSharedParametersUsage const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParametersUsage.get_shared_params

  call-seq:
    get_shared_params -> GpuSharedParametersPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParametersUsage_get_shared_params(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);
  {
    try {
      result = ((Ogre::GpuSharedParametersUsage const *)arg1)->getSharedParams();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuSharedParametersPtr(static_cast< const Ogre::GpuSharedParametersPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParametersUsage.get_target_params

  call-seq:
    get_target_params -> GpuProgramParameters

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParametersUsage_get_target_params(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);
  {
    try {
      result = (Ogre::GpuProgramParameters *)((Ogre::GpuSharedParametersUsage const *)arg1)->getTargetParams();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramParameters, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParametersUsage._set_render_system_data

  call-seq:
    _set_render_system_data(Any data)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParametersUsage__set_render_system_data(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);
  {
    try {
      ((Ogre::GpuSharedParametersUsage const *)arg1)->_setRenderSystemData((Ogre::Any const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuSharedParametersUsage._get_render_system_data

  call-seq:
    _get_render_system_data -> Any

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuSharedParametersUsage__get_render_system_data(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);
  {
    try {
      result = (Ogre::Any *) &((Ogre::GpuSharedParametersUsage const *)arg1)->_getRenderSystemData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuSharedParametersUsage(Ogre::GpuSharedParametersUsage *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::GpuProgramParameters

  Proxy of C++ Ogre::GpuProgramParameters class


*/
swig_class SwigClassGpuProgramParameters;


/*
  Document-method: Ogre::AutoConstantType.ACT_WORLD_MATRIX

  call-seq:
    ACT_WORLD_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_WORLD_MATRIX

  call-seq:
    ACT_INVERSE_WORLD_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TRANSPOSE_WORLD_MATRIX

  call-seq:
    ACT_TRANSPOSE_WORLD_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_TRANSPOSE_WORLD_MATRIX

  call-seq:
    ACT_INVERSE_TRANSPOSE_WORLD_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_WORLD_MATRIX_ARRAY_3x4

  call-seq:
    ACT_WORLD_MATRIX_ARRAY_3x4 -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_WORLD_MATRIX_ARRAY

  call-seq:
    ACT_WORLD_MATRIX_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_WORLD_DUALQUATERNION_ARRAY_2x4

  call-seq:
    ACT_WORLD_DUALQUATERNION_ARRAY_2x4 -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_WORLD_SCALE_SHEAR_MATRIX_ARRAY_3x4

  call-seq:
    ACT_WORLD_SCALE_SHEAR_MATRIX_ARRAY_3x4 -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_VIEW_MATRIX

  call-seq:
    ACT_VIEW_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_VIEW_MATRIX

  call-seq:
    ACT_INVERSE_VIEW_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TRANSPOSE_VIEW_MATRIX

  call-seq:
    ACT_TRANSPOSE_VIEW_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_TRANSPOSE_VIEW_MATRIX

  call-seq:
    ACT_INVERSE_TRANSPOSE_VIEW_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_PROJECTION_MATRIX

  call-seq:
    ACT_PROJECTION_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_PROJECTION_MATRIX

  call-seq:
    ACT_INVERSE_PROJECTION_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TRANSPOSE_PROJECTION_MATRIX

  call-seq:
    ACT_TRANSPOSE_PROJECTION_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX

  call-seq:
    ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_VIEWPROJ_MATRIX

  call-seq:
    ACT_VIEWPROJ_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_VIEWPROJ_MATRIX

  call-seq:
    ACT_INVERSE_VIEWPROJ_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TRANSPOSE_VIEWPROJ_MATRIX

  call-seq:
    ACT_TRANSPOSE_VIEWPROJ_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX

  call-seq:
    ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_WORLDVIEW_MATRIX

  call-seq:
    ACT_WORLDVIEW_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_WORLDVIEW_MATRIX

  call-seq:
    ACT_INVERSE_WORLDVIEW_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TRANSPOSE_WORLDVIEW_MATRIX

  call-seq:
    ACT_TRANSPOSE_WORLDVIEW_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX

  call-seq:
    ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_WORLDVIEWPROJ_MATRIX

  call-seq:
    ACT_WORLDVIEWPROJ_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_WORLDVIEWPROJ_MATRIX

  call-seq:
    ACT_INVERSE_WORLDVIEWPROJ_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX

  call-seq:
    ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX

  call-seq:
    ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_RENDER_TARGET_FLIPPING

  call-seq:
    ACT_RENDER_TARGET_FLIPPING -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_VERTEX_WINDING

  call-seq:
    ACT_VERTEX_WINDING -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_FOG_COLOUR

  call-seq:
    ACT_FOG_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_FOG_PARAMS

  call-seq:
    ACT_FOG_PARAMS -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SURFACE_AMBIENT_COLOUR

  call-seq:
    ACT_SURFACE_AMBIENT_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SURFACE_DIFFUSE_COLOUR

  call-seq:
    ACT_SURFACE_DIFFUSE_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SURFACE_SPECULAR_COLOUR

  call-seq:
    ACT_SURFACE_SPECULAR_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SURFACE_EMISSIVE_COLOUR

  call-seq:
    ACT_SURFACE_EMISSIVE_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SURFACE_SHININESS

  call-seq:
    ACT_SURFACE_SHININESS -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_COUNT

  call-seq:
    ACT_LIGHT_COUNT -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_AMBIENT_LIGHT_COLOUR

  call-seq:
    ACT_AMBIENT_LIGHT_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_DIFFUSE_COLOUR

  call-seq:
    ACT_LIGHT_DIFFUSE_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_SPECULAR_COLOUR

  call-seq:
    ACT_LIGHT_SPECULAR_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_ATTENUATION

  call-seq:
    ACT_LIGHT_ATTENUATION -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SPOTLIGHT_PARAMS

  call-seq:
    ACT_SPOTLIGHT_PARAMS -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_POSITION

  call-seq:
    ACT_LIGHT_POSITION -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_POSITION_OBJECT_SPACE

  call-seq:
    ACT_LIGHT_POSITION_OBJECT_SPACE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_POSITION_VIEW_SPACE

  call-seq:
    ACT_LIGHT_POSITION_VIEW_SPACE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_DIRECTION

  call-seq:
    ACT_LIGHT_DIRECTION -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_DIRECTION_OBJECT_SPACE

  call-seq:
    ACT_LIGHT_DIRECTION_OBJECT_SPACE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_DIRECTION_VIEW_SPACE

  call-seq:
    ACT_LIGHT_DIRECTION_VIEW_SPACE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_DISTANCE_OBJECT_SPACE

  call-seq:
    ACT_LIGHT_DISTANCE_OBJECT_SPACE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_POWER_SCALE

  call-seq:
    ACT_LIGHT_POWER_SCALE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED

  call-seq:
    ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED

  call-seq:
    ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_DIFFUSE_COLOUR_ARRAY

  call-seq:
    ACT_LIGHT_DIFFUSE_COLOUR_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_SPECULAR_COLOUR_ARRAY

  call-seq:
    ACT_LIGHT_SPECULAR_COLOUR_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY

  call-seq:
    ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED_ARRAY

  call-seq:
    ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_ATTENUATION_ARRAY

  call-seq:
    ACT_LIGHT_ATTENUATION_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_POSITION_ARRAY

  call-seq:
    ACT_LIGHT_POSITION_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY

  call-seq:
    ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY

  call-seq:
    ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_DIRECTION_ARRAY

  call-seq:
    ACT_LIGHT_DIRECTION_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY

  call-seq:
    ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY

  call-seq:
    ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY

  call-seq:
    ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_POWER_SCALE_ARRAY

  call-seq:
    ACT_LIGHT_POWER_SCALE_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SPOTLIGHT_PARAMS_ARRAY

  call-seq:
    ACT_SPOTLIGHT_PARAMS_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_DERIVED_AMBIENT_LIGHT_COLOUR

  call-seq:
    ACT_DERIVED_AMBIENT_LIGHT_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_DERIVED_SCENE_COLOUR

  call-seq:
    ACT_DERIVED_SCENE_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_DERIVED_LIGHT_DIFFUSE_COLOUR

  call-seq:
    ACT_DERIVED_LIGHT_DIFFUSE_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_DERIVED_LIGHT_SPECULAR_COLOUR

  call-seq:
    ACT_DERIVED_LIGHT_SPECULAR_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY

  call-seq:
    ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY

  call-seq:
    ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_NUMBER

  call-seq:
    ACT_LIGHT_NUMBER -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_CASTS_SHADOWS

  call-seq:
    ACT_LIGHT_CASTS_SHADOWS -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SHADOW_EXTRUSION_DISTANCE

  call-seq:
    ACT_SHADOW_EXTRUSION_DISTANCE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_CAMERA_POSITION

  call-seq:
    ACT_CAMERA_POSITION -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_CAMERA_POSITION_OBJECT_SPACE

  call-seq:
    ACT_CAMERA_POSITION_OBJECT_SPACE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TEXTURE_VIEWPROJ_MATRIX

  call-seq:
    ACT_TEXTURE_VIEWPROJ_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TEXTURE_VIEWPROJ_MATRIX_ARRAY

  call-seq:
    ACT_TEXTURE_VIEWPROJ_MATRIX_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TEXTURE_WORLDVIEWPROJ_MATRIX

  call-seq:
    ACT_TEXTURE_WORLDVIEWPROJ_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TEXTURE_WORLDVIEWPROJ_MATRIX_ARRAY

  call-seq:
    ACT_TEXTURE_WORLDVIEWPROJ_MATRIX_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SPOTLIGHT_VIEWPROJ_MATRIX

  call-seq:
    ACT_SPOTLIGHT_VIEWPROJ_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SPOTLIGHT_VIEWPROJ_MATRIX_ARRAY

  call-seq:
    ACT_SPOTLIGHT_VIEWPROJ_MATRIX_ARRAY -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX

  call-seq:
    ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_CUSTOM

  call-seq:
    ACT_CUSTOM -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TIME

  call-seq:
    ACT_TIME -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TIME_0_X

  call-seq:
    ACT_TIME_0_X -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_COSTIME_0_X

  call-seq:
    ACT_COSTIME_0_X -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SINTIME_0_X

  call-seq:
    ACT_SINTIME_0_X -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TANTIME_0_X

  call-seq:
    ACT_TANTIME_0_X -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TIME_0_X_PACKED

  call-seq:
    ACT_TIME_0_X_PACKED -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TIME_0_1

  call-seq:
    ACT_TIME_0_1 -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_COSTIME_0_1

  call-seq:
    ACT_COSTIME_0_1 -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SINTIME_0_1

  call-seq:
    ACT_SINTIME_0_1 -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TANTIME_0_1

  call-seq:
    ACT_TANTIME_0_1 -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TIME_0_1_PACKED

  call-seq:
    ACT_TIME_0_1_PACKED -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TIME_0_2PI

  call-seq:
    ACT_TIME_0_2PI -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_COSTIME_0_2PI

  call-seq:
    ACT_COSTIME_0_2PI -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SINTIME_0_2PI

  call-seq:
    ACT_SINTIME_0_2PI -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TANTIME_0_2PI

  call-seq:
    ACT_TANTIME_0_2PI -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TIME_0_2PI_PACKED

  call-seq:
    ACT_TIME_0_2PI_PACKED -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_FRAME_TIME

  call-seq:
    ACT_FRAME_TIME -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_FPS

  call-seq:
    ACT_FPS -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_VIEWPORT_WIDTH

  call-seq:
    ACT_VIEWPORT_WIDTH -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_VIEWPORT_HEIGHT

  call-seq:
    ACT_VIEWPORT_HEIGHT -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_VIEWPORT_WIDTH

  call-seq:
    ACT_INVERSE_VIEWPORT_WIDTH -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_VIEWPORT_HEIGHT

  call-seq:
    ACT_INVERSE_VIEWPORT_HEIGHT -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_VIEWPORT_SIZE

  call-seq:
    ACT_VIEWPORT_SIZE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_VIEW_DIRECTION

  call-seq:
    ACT_VIEW_DIRECTION -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_VIEW_SIDE_VECTOR

  call-seq:
    ACT_VIEW_SIDE_VECTOR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_VIEW_UP_VECTOR

  call-seq:
    ACT_VIEW_UP_VECTOR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_FOV

  call-seq:
    ACT_FOV -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_NEAR_CLIP_DISTANCE

  call-seq:
    ACT_NEAR_CLIP_DISTANCE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_FAR_CLIP_DISTANCE

  call-seq:
    ACT_FAR_CLIP_DISTANCE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_PASS_NUMBER

  call-seq:
    ACT_PASS_NUMBER -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_PASS_ITERATION_NUMBER

  call-seq:
    ACT_PASS_ITERATION_NUMBER -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_ANIMATION_PARAMETRIC

  call-seq:
    ACT_ANIMATION_PARAMETRIC -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TEXEL_OFFSETS

  call-seq:
    ACT_TEXEL_OFFSETS -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SCENE_DEPTH_RANGE

  call-seq:
    ACT_SCENE_DEPTH_RANGE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SHADOW_SCENE_DEPTH_RANGE

  call-seq:
    ACT_SHADOW_SCENE_DEPTH_RANGE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_SHADOW_COLOUR

  call-seq:
    ACT_SHADOW_COLOUR -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TEXTURE_SIZE

  call-seq:
    ACT_TEXTURE_SIZE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_INVERSE_TEXTURE_SIZE

  call-seq:
    ACT_INVERSE_TEXTURE_SIZE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_PACKED_TEXTURE_SIZE

  call-seq:
    ACT_PACKED_TEXTURE_SIZE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_TEXTURE_MATRIX

  call-seq:
    ACT_TEXTURE_MATRIX -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LOD_CAMERA_POSITION

  call-seq:
    ACT_LOD_CAMERA_POSITION -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LOD_CAMERA_POSITION_OBJECT_SPACE

  call-seq:
    ACT_LOD_CAMERA_POSITION_OBJECT_SPACE -> int

A class method.

*/

/*
  Document-method: Ogre::AutoConstantType.ACT_LIGHT_CUSTOM

  call-seq:
    ACT_LIGHT_CUSTOM -> int

A class method.

*/

/*
  Document-method: Ogre::ACDataType.ACDT_NONE

  call-seq:
    ACDT_NONE -> int

A class method.

*/

/*
  Document-method: Ogre::ACDataType.ACDT_INT

  call-seq:
    ACDT_INT -> int

A class method.

*/

/*
  Document-method: Ogre::ACDataType.ACDT_REAL

  call-seq:
    ACDT_REAL -> int

A class method.

*/

/*
  Document-method: Ogre::ElementType.ET_INT

  call-seq:
    ET_INT -> int

A class method.

*/

/*
  Document-method: Ogre::ElementType.ET_REAL

  call-seq:
    ET_REAL -> int

A class method.

*/

/*
  Document-method: Ogre::GpuProgramParameters.new

  call-seq:
    GpuProgramParameters.new
    GpuProgramParameters.new(GpuProgramParameters oth)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::GpuProgramParameters *)new Ogre::GpuProgramParameters();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_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);
  {
    try {
      result = (Ogre::GpuProgramParameters *)new Ogre::GpuProgramParameters((Ogre::GpuProgramParameters const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::GpuProgramParameters._set_named_constants

  call-seq:
    _set_named_constants(GpuNamedConstantsPtr constantmap)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__set_named_constants(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);
  {
    try {
      (arg1)->_setNamedConstants((Ogre::GpuNamedConstantsPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._set_logical_indexes

  call-seq:
    _set_logical_indexes(GpuLogicalBufferStructPtr floatIndexMap, GpuLogicalBufferStructPtr intIndexMap)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__set_logical_indexes(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);
  {
    try {
      (arg1)->_setLogicalIndexes((Ogre::GpuLogicalBufferStructPtr const &)*arg2,(Ogre::GpuLogicalBufferStructPtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.has_named_parameters

  call-seq:
    has_named_parameters -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_has_named_parameters(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);
  {
    try {
      result = (bool)((Ogre::GpuProgramParameters const *)arg1)->hasNamedParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.has_logical_indexed_parameters

  call-seq:
    has_logical_indexed_parameters -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_has_logical_indexed_parameters(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);
  {
    try {
      result = (bool)((Ogre::GpuProgramParameters const *)arg1)->hasLogicalIndexedParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.set_constant

  call-seq:
    set_constant(size_t index, Vector4 vec)
    set_constant(size_t index, Real val)
    set_constant(size_t index, Vector3 vec)
    set_constant(size_t index, Matrix4 m)
    set_constant(size_t index, Matrix4 m, size_t numEntries)
    set_constant(size_t index, float val, size_t count)
    set_constant(size_t index, double val, size_t count)
    set_constant(size_t index, ColourValue colour)
    set_constant(size_t index, int val, size_t count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_constant__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);
  {
    try {
      (arg1)->setConstant(arg2,(Ogre::Vector4 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_constant__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);
  {
    try {
      (arg1)->setConstant(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_constant__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);
  {
    try {
      (arg1)->setConstant(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_constant__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);
  {
    try {
      (arg1)->setConstant(arg2,(Ogre::Matrix4 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_constant__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);
  {
    try {
      (arg1)->setConstant(arg2,(Ogre::Matrix4 const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_constant__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);
  {
    try {
      (arg1)->setConstant(arg2,(float const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_constant__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);
  {
    try {
      (arg1)->setConstant(arg2,(double const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_constant__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);
  {
    try {
      (arg1)->setConstant(arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_constant__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);
  {
    try {
      (arg1)->setConstant(arg2,(int const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_set_constant(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_set_constant__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_set_constant__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_set_constant__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_set_constant__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_set_constant__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_set_constant__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_set_constant__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_set_constant__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_set_constant__SWIG_8(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuProgramParameters.set_constant", 
    "    void GpuProgramParameters.set_constant(size_t index, Ogre::Vector4 const &vec)\n"
    "    void GpuProgramParameters.set_constant(size_t index, Ogre::Real val)\n"
    "    void GpuProgramParameters.set_constant(size_t index, Ogre::Vector3 const &vec)\n"
    "    void GpuProgramParameters.set_constant(size_t index, Ogre::Matrix4 const &m)\n"
    "    void GpuProgramParameters.set_constant(size_t index, Ogre::Matrix4 const *m, size_t numEntries)\n"
    "    void GpuProgramParameters.set_constant(size_t index, float const *val, size_t count)\n"
    "    void GpuProgramParameters.set_constant(size_t index, double const *val, size_t count)\n"
    "    void GpuProgramParameters.set_constant(size_t index, Ogre::ColourValue const &colour)\n"
    "    void GpuProgramParameters.set_constant(size_t index, int const *val, size_t count)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._write_raw_constants

  call-seq:
    _write_raw_constants(size_t physicalIndex, float val, size_t count)
    _write_raw_constants(size_t physicalIndex, double val, size_t count)
    _write_raw_constants(size_t physicalIndex, int val, size_t count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__write_raw_constants__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);
  {
    try {
      (arg1)->_writeRawConstants(arg2,(float const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__write_raw_constants__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);
  {
    try {
      (arg1)->_writeRawConstants(arg2,(double const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__write_raw_constants__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);
  {
    try {
      (arg1)->_writeRawConstants(arg2,(int const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters__write_raw_constants(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__write_raw_constants__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__write_raw_constants__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__write_raw_constants__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuProgramParameters._write_raw_constants", 
    "    void GpuProgramParameters._write_raw_constants(size_t physicalIndex, float const *val, size_t count)\n"
    "    void GpuProgramParameters._write_raw_constants(size_t physicalIndex, double const *val, size_t count)\n"
    "    void GpuProgramParameters._write_raw_constants(size_t physicalIndex, int const *val, size_t count)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._read_raw_constants

  call-seq:
    _read_raw_constants(size_t physicalIndex, size_t count, float dest)
    _read_raw_constants(size_t physicalIndex, size_t count, int dest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__read_raw_constants__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);
  {
    try {
      (arg1)->_readRawConstants(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__read_raw_constants__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);
  {
    try {
      (arg1)->_readRawConstants(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters__read_raw_constants(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__read_raw_constants__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__read_raw_constants__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuProgramParameters._read_raw_constants", 
    "    void GpuProgramParameters._read_raw_constants(size_t physicalIndex, size_t count, float *dest)\n"
    "    void GpuProgramParameters._read_raw_constants(size_t physicalIndex, size_t count, int *dest)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._write_raw_constant

  call-seq:
    _write_raw_constant(size_t physicalIndex, Vector4 vec, size_t count=4)
    _write_raw_constant(size_t physicalIndex, Vector4 vec)
    _write_raw_constant(size_t physicalIndex, Real val)
    _write_raw_constant(size_t physicalIndex, int val)
    _write_raw_constant(size_t physicalIndex, Vector3 vec)
    _write_raw_constant(size_t physicalIndex, Matrix4 m, size_t elementCount)
    _write_raw_constant(size_t physicalIndex, Matrix4 m, size_t numEntries)
    _write_raw_constant(size_t physicalIndex, ColourValue colour, size_t count=4)
    _write_raw_constant(size_t physicalIndex, ColourValue colour)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__write_raw_constant__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);
  {
    try {
      (arg1)->_writeRawConstant(arg2,(Ogre::Vector4 const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__write_raw_constant__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);
  {
    try {
      (arg1)->_writeRawConstant(arg2,(Ogre::Vector4 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__write_raw_constant__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);
  {
    try {
      (arg1)->_writeRawConstant(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__write_raw_constant__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);
  {
    try {
      (arg1)->_writeRawConstant(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__write_raw_constant__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);
  {
    try {
      (arg1)->_writeRawConstant(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__write_raw_constant__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);
  {
    try {
      (arg1)->_writeRawConstant(arg2,(Ogre::Matrix4 const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__write_raw_constant__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);
  {
    try {
      (arg1)->_writeRawConstant(arg2,(Ogre::Matrix4 const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__write_raw_constant__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);
  {
    try {
      (arg1)->_writeRawConstant(arg2,(Ogre::ColourValue const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__write_raw_constant__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);
  {
    try {
      (arg1)->_writeRawConstant(arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters__write_raw_constant(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__write_raw_constant__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__write_raw_constant__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__write_raw_constant__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__write_raw_constant__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__write_raw_constant__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__write_raw_constant__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__write_raw_constant__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__write_raw_constant__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__write_raw_constant__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuProgramParameters._write_raw_constant", 
    "    void GpuProgramParameters._write_raw_constant(size_t physicalIndex, Ogre::Vector4 const &vec, size_t count)\n"
    "    void GpuProgramParameters._write_raw_constant(size_t physicalIndex, Ogre::Vector4 const &vec)\n"
    "    void GpuProgramParameters._write_raw_constant(size_t physicalIndex, Ogre::Real val)\n"
    "    void GpuProgramParameters._write_raw_constant(size_t physicalIndex, int val)\n"
    "    void GpuProgramParameters._write_raw_constant(size_t physicalIndex, Ogre::Vector3 const &vec)\n"
    "    void GpuProgramParameters._write_raw_constant(size_t physicalIndex, Ogre::Matrix4 const &m, size_t elementCount)\n"
    "    void GpuProgramParameters._write_raw_constant(size_t physicalIndex, Ogre::Matrix4 const *m, size_t numEntries)\n"
    "    void GpuProgramParameters._write_raw_constant(size_t physicalIndex, Ogre::ColourValue const &colour, size_t count)\n"
    "    void GpuProgramParameters._write_raw_constant(size_t physicalIndex, Ogre::ColourValue const &colour)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_constant_definition_iterator

  call-seq:
    get_constant_definition_iterator -> GpuConstantDefinitionIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_constant_definition_iterator(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);
  {
    try {
      result = ((Ogre::GpuProgramParameters const *)arg1)->getConstantDefinitionIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_constant_definition

  call-seq:
    get_constant_definition(String name) -> GpuConstantDefinition

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_constant_definition(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;
  }
  {
    try {
      result = (Ogre::GpuConstantDefinition *) &((Ogre::GpuProgramParameters const *)arg1)->getConstantDefinition((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuConstantDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_constant_definitions

  call-seq:
    get_constant_definitions -> GpuNamedConstants

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_constant_definitions(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);
  {
    try {
      result = (Ogre::GpuNamedConstants *) &((Ogre::GpuProgramParameters const *)arg1)->getConstantDefinitions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_float_logical_buffer_struct

  call-seq:
    get_float_logical_buffer_struct -> GpuLogicalBufferStructPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_float_logical_buffer_struct(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);
  {
    try {
      result = (Ogre::GpuLogicalBufferStructPtr *) &((Ogre::GpuProgramParameters const *)arg1)->getFloatLogicalBufferStruct();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_float_logical_index_for_physical_index

  call-seq:
    get_float_logical_index_for_physical_index(size_t physicalIndex) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_float_logical_index_for_physical_index(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);
  {
    try {
      result = (arg1)->getFloatLogicalIndexForPhysicalIndex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_int_logical_index_for_physical_index

  call-seq:
    get_int_logical_index_for_physical_index(size_t physicalIndex) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_int_logical_index_for_physical_index(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);
  {
    try {
      result = (arg1)->getIntLogicalIndexForPhysicalIndex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_int_logical_buffer_struct

  call-seq:
    get_int_logical_buffer_struct -> GpuLogicalBufferStructPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_int_logical_buffer_struct(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);
  {
    try {
      result = (Ogre::GpuLogicalBufferStructPtr *) &((Ogre::GpuProgramParameters const *)arg1)->getIntLogicalBufferStruct();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_float_constant_list

  call-seq:
    get_float_constant_list -> FloatConstantList

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_float_constant_list(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);
  {
    try {
      result = (Ogre::FloatConstantList *) &((Ogre::GpuProgramParameters const *)arg1)->getFloatConstantList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_float_pointer

  call-seq:
    get_float_pointer(size_t pos) -> float
    get_float_pointer(size_t pos) -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_float_pointer__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);
  {
    try {
      result = (float *)(arg1)->getFloatPointer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_float_pointer__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);
  {
    try {
      result = (float *)((Ogre::GpuProgramParameters const *)arg1)->getFloatPointer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_get_float_pointer(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_get_float_pointer__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_get_float_pointer__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "GpuProgramParameters.get_float_pointer", 
    "    float const * GpuProgramParameters.get_float_pointer(size_t pos)\n"
    "    float const * GpuProgramParameters.get_float_pointer(size_t pos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_int_constant_list

  call-seq:
    get_int_constant_list -> IntConstantList

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_int_constant_list(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);
  {
    try {
      result = (Ogre::IntConstantList *) &((Ogre::GpuProgramParameters const *)arg1)->getIntConstantList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_int_Ogre__STLAllocatorT_int_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_int_pointer

  call-seq:
    get_int_pointer(size_t pos) -> int
    get_int_pointer(size_t pos) -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_int_pointer__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);
  {
    try {
      result = (int *)(arg1)->getIntPointer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_int_pointer__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);
  {
    try {
      result = (int *)((Ogre::GpuProgramParameters const *)arg1)->getIntPointer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_get_int_pointer(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_get_int_pointer__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_get_int_pointer__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "GpuProgramParameters.get_int_pointer", 
    "    int const * GpuProgramParameters.get_int_pointer(size_t pos)\n"
    "    int const * GpuProgramParameters.get_int_pointer(size_t pos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_auto_constant_list

  call-seq:
    get_auto_constant_list -> AutoConstantList

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_auto_constant_list(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);
  {
    try {
      result = (Ogre::GpuProgramParameters::AutoConstantList *) &((Ogre::GpuProgramParameters const *)arg1)->getAutoConstantList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.set_auto_constant

  call-seq:
    set_auto_constant(size_t index, AutoConstantType acType, size_t extraInfo=0)
    set_auto_constant(size_t index, AutoConstantType acType)
    set_auto_constant(size_t index, AutoConstantType acType, uint16 extraInfo1, 
    uint16 extraInfo2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_auto_constant__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);
  {
    try {
      (arg1)->setAutoConstant(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_auto_constant__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);
  {
    try {
      (arg1)->setAutoConstant(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.set_auto_constant_real

  call-seq:
    set_auto_constant_real(size_t index, AutoConstantType acType, Real rData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_auto_constant_real(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);
  {
    try {
      (arg1)->setAutoConstantReal(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.set_auto_constant

  call-seq:
    set_auto_constant(size_t index, AutoConstantType acType, size_t extraInfo=0)
    set_auto_constant(size_t index, AutoConstantType acType)
    set_auto_constant(size_t index, AutoConstantType acType, uint16 extraInfo1, 
    uint16 extraInfo2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_auto_constant__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);
  {
    try {
      (arg1)->setAutoConstant(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_set_auto_constant(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_set_auto_constant__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_set_auto_constant__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_set_auto_constant__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "GpuProgramParameters.set_auto_constant", 
    "    void GpuProgramParameters.set_auto_constant(size_t index, Ogre::GpuProgramParameters::AutoConstantType acType, size_t extraInfo)\n"
    "    void GpuProgramParameters.set_auto_constant(size_t index, Ogre::GpuProgramParameters::AutoConstantType acType)\n"
    "    void GpuProgramParameters.set_auto_constant(size_t index, Ogre::GpuProgramParameters::AutoConstantType acType, Ogre::uint16 extraInfo1, Ogre::uint16 extraInfo2)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._set_raw_auto_constant

  call-seq:
    _set_raw_auto_constant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo, 
    uint16 variability, size_t elementSize=4)
    _set_raw_auto_constant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo, 
    uint16 variability)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__set_raw_auto_constant__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);
  {
    try {
      (arg1)->_setRawAutoConstant(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__set_raw_auto_constant__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);
  {
    try {
      (arg1)->_setRawAutoConstant(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters__set_raw_auto_constant(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__set_raw_auto_constant__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__set_raw_auto_constant__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "GpuProgramParameters._set_raw_auto_constant", 
    "    void GpuProgramParameters._set_raw_auto_constant(size_t physicalIndex, Ogre::GpuProgramParameters::AutoConstantType acType, size_t extraInfo, Ogre::uint16 variability, size_t elementSize)\n"
    "    void GpuProgramParameters._set_raw_auto_constant(size_t physicalIndex, Ogre::GpuProgramParameters::AutoConstantType acType, size_t extraInfo, Ogre::uint16 variability)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._set_raw_auto_constant_real

  call-seq:
    _set_raw_auto_constant_real(size_t physicalIndex, AutoConstantType acType, Real rData, 
    uint16 variability, size_t elementSize=4)
    _set_raw_auto_constant_real(size_t physicalIndex, AutoConstantType acType, Real rData, 
    uint16 variability)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__set_raw_auto_constant_real__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);
  {
    try {
      (arg1)->_setRawAutoConstantReal(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__set_raw_auto_constant_real__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);
  {
    try {
      (arg1)->_setRawAutoConstantReal(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters__set_raw_auto_constant_real(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__set_raw_auto_constant_real__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__set_raw_auto_constant_real__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "GpuProgramParameters._set_raw_auto_constant_real", 
    "    void GpuProgramParameters._set_raw_auto_constant_real(size_t physicalIndex, Ogre::GpuProgramParameters::AutoConstantType acType, Ogre::Real rData, Ogre::uint16 variability, size_t elementSize)\n"
    "    void GpuProgramParameters._set_raw_auto_constant_real(size_t physicalIndex, Ogre::GpuProgramParameters::AutoConstantType acType, Ogre::Real rData, Ogre::uint16 variability)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.clear_auto_constant

  call-seq:
    clear_auto_constant(size_t index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_clear_auto_constant(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);
  {
    try {
      (arg1)->clearAutoConstant(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.set_constant_from_time

  call-seq:
    set_constant_from_time(size_t index, Real factor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_constant_from_time(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);
  {
    try {
      (arg1)->setConstantFromTime(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.clear_auto_constants

  call-seq:
    clear_auto_constants

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_clear_auto_constants(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);
  {
    try {
      (arg1)->clearAutoConstants();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_auto_constant_iterator

  call-seq:
    get_auto_constant_iterator -> AutoConstantIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_auto_constant_iterator(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);
  {
    try {
      result = ((Ogre::GpuProgramParameters const *)arg1)->getAutoConstantIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_auto_constant_count

  call-seq:
    get_auto_constant_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_auto_constant_count(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);
  {
    try {
      result = ((Ogre::GpuProgramParameters const *)arg1)->getAutoConstantCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_auto_constant_entry

  call-seq:
    get_auto_constant_entry(size_t index) -> AutoConstantEntry

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_auto_constant_entry(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);
  {
    try {
      result = (AutoConstantEntry *)(arg1)->getAutoConstantEntry(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AutoConstantEntry, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.has_auto_constants

  call-seq:
    has_auto_constants -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_has_auto_constants(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);
  {
    try {
      result = (bool)((Ogre::GpuProgramParameters const *)arg1)->hasAutoConstants();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.find_float_auto_constant_entry

  call-seq:
    find_float_auto_constant_entry(size_t logicalIndex) -> AutoConstantEntry

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_find_float_auto_constant_entry(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);
  {
    try {
      result = (AutoConstantEntry *)(arg1)->findFloatAutoConstantEntry(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AutoConstantEntry, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.find_int_auto_constant_entry

  call-seq:
    find_int_auto_constant_entry(size_t logicalIndex) -> AutoConstantEntry

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_find_int_auto_constant_entry(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);
  {
    try {
      result = (AutoConstantEntry *)(arg1)->findIntAutoConstantEntry(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AutoConstantEntry, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.find_auto_constant_entry

  call-seq:
    find_auto_constant_entry(String paramName) -> AutoConstantEntry

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_find_auto_constant_entry(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;
  }
  {
    try {
      result = (AutoConstantEntry *)(arg1)->findAutoConstantEntry((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AutoConstantEntry, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._find_raw_auto_constant_entry_float

  call-seq:
    _find_raw_auto_constant_entry_float(size_t physicalIndex) -> AutoConstantEntry

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__find_raw_auto_constant_entry_float(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);
  {
    try {
      result = (AutoConstantEntry *)(arg1)->_findRawAutoConstantEntryFloat(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AutoConstantEntry, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._find_raw_auto_constant_entry_int

  call-seq:
    _find_raw_auto_constant_entry_int(size_t physicalIndex) -> AutoConstantEntry

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__find_raw_auto_constant_entry_int(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);
  {
    try {
      result = (AutoConstantEntry *)(arg1)->_findRawAutoConstantEntryInt(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AutoConstantEntry, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._update_auto_params

  call-seq:
    _update_auto_params(AutoParamDataSource source, uint16 variabilityMask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__update_auto_params(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);
  {
    try {
      (arg1)->_updateAutoParams((Ogre::AutoParamDataSource const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.set_ignore_missing_params

  call-seq:
    set_ignore_missing_params(bool state)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_ignore_missing_params(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);
  {
    try {
      (arg1)->setIgnoreMissingParams(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.set_named_constant

  call-seq:
    set_named_constant(String name, Real val)
    set_named_constant(String name, int val)
    set_named_constant(String name, Vector4 vec)
    set_named_constant(String name, Vector3 vec)
    set_named_constant(String name, Matrix4 m)
    set_named_constant(String name, Matrix4 m, size_t numEntries)
    set_named_constant(String name, float val, size_t count, size_t multiple=4)
    set_named_constant(String name, float val, size_t count)
    set_named_constant(String name, double val, size_t count, size_t multiple=4)
    set_named_constant(String name, double val, size_t count)
    set_named_constant(String name, ColourValue colour)
    set_named_constant(String name, int val, size_t count, size_t multiple=4)
    set_named_constant(String name, int val, size_t count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Vector4 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Matrix4 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Matrix4 const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(float const *)arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(float const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(double const *)arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(double const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(int const *)arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant__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);
  {
    try {
      (arg1)->setNamedConstant((Ogre::String const &)*arg2,(int const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_set_named_constant(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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__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_set_named_constant__SWIG_6(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "GpuProgramParameters.set_named_constant", 
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, Ogre::Real val)\n"
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, int val)\n"
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, Ogre::Vector4 const &vec)\n"
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, Ogre::Vector3 const &vec)\n"
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, Ogre::Matrix4 const &m)\n"
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, Ogre::Matrix4 const *m, size_t numEntries)\n"
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, float const *val, size_t count, size_t multiple)\n"
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, float const *val, size_t count)\n"
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, double const *val, size_t count, size_t multiple)\n"
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, double const *val, size_t count)\n"
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, Ogre::ColourValue const &colour)\n"
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, int const *val, size_t count, size_t multiple)\n"
    "    void GpuProgramParameters.set_named_constant(Ogre::String const &name, int const *val, size_t count)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.set_named_auto_constant

  call-seq:
    set_named_auto_constant(String name, AutoConstantType acType, size_t extraInfo=0)
    set_named_auto_constant(String name, AutoConstantType acType)
    set_named_auto_constant(String name, AutoConstantType acType, uint16 extraInfo1, 
    uint16 extraInfo2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_auto_constant__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);
  {
    try {
      (arg1)->setNamedAutoConstant((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_auto_constant__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);
  {
    try {
      (arg1)->setNamedAutoConstant((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.set_named_auto_constant_real

  call-seq:
    set_named_auto_constant_real(String name, AutoConstantType acType, Real rData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_auto_constant_real(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);
  {
    try {
      (arg1)->setNamedAutoConstantReal((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.set_named_auto_constant

  call-seq:
    set_named_auto_constant(String name, AutoConstantType acType, size_t extraInfo=0)
    set_named_auto_constant(String name, AutoConstantType acType)
    set_named_auto_constant(String name, AutoConstantType acType, uint16 extraInfo1, 
    uint16 extraInfo2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_auto_constant__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);
  {
    try {
      (arg1)->setNamedAutoConstant((Ogre::String const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_set_named_auto_constant(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_set_named_auto_constant__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_set_named_auto_constant__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_set_named_auto_constant__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "GpuProgramParameters.set_named_auto_constant", 
    "    void GpuProgramParameters.set_named_auto_constant(Ogre::String const &name, Ogre::GpuProgramParameters::AutoConstantType acType, size_t extraInfo)\n"
    "    void GpuProgramParameters.set_named_auto_constant(Ogre::String const &name, Ogre::GpuProgramParameters::AutoConstantType acType)\n"
    "    void GpuProgramParameters.set_named_auto_constant(Ogre::String const &name, Ogre::GpuProgramParameters::AutoConstantType acType, Ogre::uint16 extraInfo1, Ogre::uint16 extraInfo2)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.set_named_constant_from_time

  call-seq:
    set_named_constant_from_time(String name, Real factor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_named_constant_from_time(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);
  {
    try {
      (arg1)->setNamedConstantFromTime((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.clear_named_auto_constant

  call-seq:
    clear_named_auto_constant(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_clear_named_auto_constant(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;
  }
  {
    try {
      (arg1)->clearNamedAutoConstant((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._find_named_constant_definition

  call-seq:
    _find_named_constant_definition(String name, bool throwExceptionIfMissing=false) -> GpuConstantDefinition
    _find_named_constant_definition(String name) -> GpuConstantDefinition

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__find_named_constant_definition__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);
  {
    try {
      result = (Ogre::GpuConstantDefinition *)((Ogre::GpuProgramParameters const *)arg1)->_findNamedConstantDefinition((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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__find_named_constant_definition__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;
  }
  {
    try {
      result = (Ogre::GpuConstantDefinition *)((Ogre::GpuProgramParameters const *)arg1)->_findNamedConstantDefinition((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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__find_named_constant_definition(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__find_named_constant_definition__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__find_named_constant_definition__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "GpuProgramParameters._find_named_constant_definition", 
    "    Ogre::GpuConstantDefinition const * GpuProgramParameters._find_named_constant_definition(Ogre::String const &name, bool throwExceptionIfMissing)\n"
    "    Ogre::GpuConstantDefinition const * GpuProgramParameters._find_named_constant_definition(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._get_float_constant_physical_index

  call-seq:
    _get_float_constant_physical_index(size_t logicalIndex, size_t requestedSize, uint16 variability) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__get_float_constant_physical_index(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);
  {
    try {
      result = (arg1)->_getFloatConstantPhysicalIndex(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._get_int_constant_physical_index

  call-seq:
    _get_int_constant_physical_index(size_t logicalIndex, size_t requestedSize, uint16 variability) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__get_int_constant_physical_index(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);
  {
    try {
      result = (arg1)->_getIntConstantPhysicalIndex(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.set_transpose_matrices

  call-seq:
    set_transpose_matrices(bool val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_set_transpose_matrices(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);
  {
    try {
      (arg1)->setTransposeMatrices(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_transpose_matrices

  call-seq:
    get_transpose_matrices -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_transpose_matrices(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);
  {
    try {
      result = (bool)((Ogre::GpuProgramParameters const *)arg1)->getTransposeMatrices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.copy_constants_from

  call-seq:
    copy_constants_from(GpuProgramParameters source)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_copy_constants_from(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);
  {
    try {
      (arg1)->copyConstantsFrom((Ogre::GpuProgramParameters const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.copy_matching_named_constants_from

  call-seq:
    copy_matching_named_constants_from(GpuProgramParameters source)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_copy_matching_named_constants_from(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);
  {
    try {
      (arg1)->copyMatchingNamedConstantsFrom((Ogre::GpuProgramParameters const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_auto_constant_definition

  call-seq:
    get_auto_constant_definition(String name) -> AutoConstantDefinition
    get_auto_constant_definition(size_t idx) -> AutoConstantDefinition

A class method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_auto_constant_definition__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;
  }
  {
    try {
      result = (Ogre::GpuProgramParameters::AutoConstantDefinition *)Ogre::GpuProgramParameters::getAutoConstantDefinition((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_get_auto_constant_definition__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);
  {
    try {
      result = (Ogre::GpuProgramParameters::AutoConstantDefinition *)Ogre::GpuProgramParameters::getAutoConstantDefinition(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramParameters__AutoConstantDefinition, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_get_auto_constant_definition(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_get_auto_constant_definition__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_get_auto_constant_definition__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "GpuProgramParameters.get_auto_constant_definition", 
    "    Ogre::GpuProgramParameters::AutoConstantDefinition const * GpuProgramParameters.get_auto_constant_definition(Ogre::String const &name)\n"
    "    Ogre::GpuProgramParameters::AutoConstantDefinition const * GpuProgramParameters.get_auto_constant_definition(size_t const idx)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_num_auto_constant_definitions

  call-seq:
    get_num_auto_constant_definitions -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_num_auto_constant_definitions(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;
  }
  {
    try {
      result = Ogre::GpuProgramParameters::getNumAutoConstantDefinitions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.inc_pass_iteration_number

  call-seq:
    inc_pass_iteration_number

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_inc_pass_iteration_number(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);
  {
    try {
      (arg1)->incPassIterationNumber();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.has_pass_iteration_number

  call-seq:
    has_pass_iteration_number -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_has_pass_iteration_number(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);
  {
    try {
      result = (bool)((Ogre::GpuProgramParameters const *)arg1)->hasPassIterationNumber();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_pass_iteration_number_index

  call-seq:
    get_pass_iteration_number_index -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_pass_iteration_number_index(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);
  {
    try {
      result = ((Ogre::GpuProgramParameters const *)arg1)->getPassIterationNumberIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.add_shared_parameters

  call-seq:
    add_shared_parameters(GpuSharedParametersPtr sharedParams)
    add_shared_parameters(String sharedParamsName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_add_shared_parameters__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));
    }
  }
  {
    try {
      (arg1)->addSharedParameters(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_add_shared_parameters__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;
  }
  {
    try {
      (arg1)->addSharedParameters((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_add_shared_parameters(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_add_shared_parameters__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_add_shared_parameters__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "GpuProgramParameters.add_shared_parameters", 
    "    void GpuProgramParameters.add_shared_parameters(Ogre::GpuSharedParametersPtr sharedParams)\n"
    "    void GpuProgramParameters.add_shared_parameters(Ogre::String const &sharedParamsName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.is_using_shared_parameters

  call-seq:
    is_using_shared_parameters(String sharedParamsName) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_is_using_shared_parameters(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;
  }
  {
    try {
      result = (bool)((Ogre::GpuProgramParameters const *)arg1)->isUsingSharedParameters((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.remove_shared_parameters

  call-seq:
    remove_shared_parameters(String sharedParamsName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_remove_shared_parameters(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;
  }
  {
    try {
      (arg1)->removeSharedParameters((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.remove_all_shared_parameters

  call-seq:
    remove_all_shared_parameters

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_remove_all_shared_parameters(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);
  {
    try {
      (arg1)->removeAllSharedParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters.get_shared_parameters

  call-seq:
    get_shared_parameters -> GpuSharedParamUsageList

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters_get_shared_parameters(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);
  {
    try {
      result = (Ogre::GpuProgramParameters::GpuSharedParamUsageList *) &((Ogre::GpuProgramParameters const *)arg1)->getSharedParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__GpuSharedParametersUsage_Ogre__STLAllocatorT_Ogre__GpuSharedParametersUsage_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._set_render_system_data

  call-seq:
    _set_render_system_data(Any data)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__set_render_system_data(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);
  {
    try {
      ((Ogre::GpuProgramParameters const *)arg1)->_setRenderSystemData((Ogre::Any const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._get_render_system_data

  call-seq:
    _get_render_system_data -> Any

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__get_render_system_data(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);
  {
    try {
      result = (Ogre::Any *) &((Ogre::GpuProgramParameters const *)arg1)->_getRenderSystemData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramParameters._copy_shared_params

  call-seq:
    _copy_shared_params

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramParameters__copy_shared_params(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);
  {
    try {
      (arg1)->_copySharedParams();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::GpuProgram < Ogre::Ogre::Resource

  Proxy of C++ Ogre::GpuProgram class


*/
swig_class SwigClassGpuProgram;

SWIGINTERN void
free_Ogre_GpuProgram(Ogre::GpuProgram *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::GpuProgram.set_source_file

  call-seq:
    set_source_file(String filename)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_set_source_file(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;
  }
  {
    try {
      (arg1)->setSourceFile((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.set_source

  call-seq:
    set_source(String source)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_set_source(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;
  }
  {
    try {
      (arg1)->setSource((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_syntax_code

  call-seq:
    get_syntax_code -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_syntax_code(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::GpuProgram const *)arg1)->getSyntaxCode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.set_syntax_code

  call-seq:
    set_syntax_code(String syntax)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_set_syntax_code(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;
  }
  {
    try {
      (arg1)->setSyntaxCode((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_source_file

  call-seq:
    get_source_file -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_source_file(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::GpuProgram const *)arg1)->getSourceFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_source

  call-seq:
    get_source -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_source(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::GpuProgram const *)arg1)->getSource();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.set_type

  call-seq:
    set_type(GpuProgramType t)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_set_type(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);
  {
    try {
      (arg1)->setType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_type

  call-seq:
    get_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_type(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);
  {
    try {
      result = (Ogre::GpuProgramType)((Ogre::GpuProgram const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram._get_binding_delegate

  call-seq:
    _get_binding_delegate -> GpuProgram

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram__get_binding_delegate(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);
  {
    try {
      result = (Ogre::GpuProgram *)(arg1)->_getBindingDelegate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgram, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.is_supported

  call-seq:
    is_supported -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_is_supported(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);
  {
    try {
      result = (bool)((Ogre::GpuProgram const *)arg1)->isSupported();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.create_parameters

  call-seq:
    create_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_create_parameters(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);
  {
    try {
      result = (arg1)->createParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.set_skeletal_animation_included

  call-seq:
    set_skeletal_animation_included(bool included)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_set_skeletal_animation_included(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);
  {
    try {
      (arg1)->setSkeletalAnimationIncluded(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.is_skeletal_animation_included

  call-seq:
    is_skeletal_animation_included -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_is_skeletal_animation_included(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);
  {
    try {
      result = (bool)((Ogre::GpuProgram const *)arg1)->isSkeletalAnimationIncluded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.set_morph_animation_included

  call-seq:
    set_morph_animation_included(bool included)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_set_morph_animation_included(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);
  {
    try {
      (arg1)->setMorphAnimationIncluded(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.set_pose_animation_included

  call-seq:
    set_pose_animation_included(ushort poseCount)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_set_pose_animation_included(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);
  {
    try {
      (arg1)->setPoseAnimationIncluded(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.is_morph_animation_included

  call-seq:
    is_morph_animation_included -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_is_morph_animation_included(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);
  {
    try {
      result = (bool)((Ogre::GpuProgram const *)arg1)->isMorphAnimationIncluded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.is_pose_animation_included

  call-seq:
    is_pose_animation_included -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_is_pose_animation_included(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);
  {
    try {
      result = (bool)((Ogre::GpuProgram const *)arg1)->isPoseAnimationIncluded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_number_of_poses_included

  call-seq:
    get_number_of_poses_included -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_number_of_poses_included(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::GpuProgram const *)arg1)->getNumberOfPosesIncluded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.set_vertex_texture_fetch_required

  call-seq:
    set_vertex_texture_fetch_required(bool r)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_set_vertex_texture_fetch_required(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);
  {
    try {
      (arg1)->setVertexTextureFetchRequired(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.is_vertex_texture_fetch_required

  call-seq:
    is_vertex_texture_fetch_required -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_is_vertex_texture_fetch_required(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);
  {
    try {
      result = (bool)((Ogre::GpuProgram const *)arg1)->isVertexTextureFetchRequired();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.set_adjacency_info_required

  call-seq:
    set_adjacency_info_required(bool r)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_set_adjacency_info_required(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);
  {
    try {
      (arg1)->setAdjacencyInfoRequired(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.is_adjacency_info_required

  call-seq:
    is_adjacency_info_required -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_is_adjacency_info_required(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);
  {
    try {
      result = (bool)((Ogre::GpuProgram const *)arg1)->isAdjacencyInfoRequired();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_default_parameters

  call-seq:
    get_default_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_default_parameters(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);
  {
    try {
      result = (arg1)->getDefaultParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.has_default_parameters

  call-seq:
    has_default_parameters -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_has_default_parameters(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);
  {
    try {
      result = (bool)((Ogre::GpuProgram const *)arg1)->hasDefaultParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_pass_surface_and_light_states

  call-seq:
    get_pass_surface_and_light_states -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_pass_surface_and_light_states(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);
  {
    try {
      result = (bool)((Ogre::GpuProgram const *)arg1)->getPassSurfaceAndLightStates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_pass_fog_states

  call-seq:
    get_pass_fog_states -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_pass_fog_states(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);
  {
    try {
      result = (bool)((Ogre::GpuProgram const *)arg1)->getPassFogStates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_pass_transform_states

  call-seq:
    get_pass_transform_states -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_pass_transform_states(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);
  {
    try {
      result = (bool)((Ogre::GpuProgram const *)arg1)->getPassTransformStates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_language

  call-seq:
    get_language -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_language(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::GpuProgram const *)arg1)->getLanguage();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.has_compile_error

  call-seq:
    has_compile_error -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_has_compile_error(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);
  {
    try {
      result = (bool)((Ogre::GpuProgram const *)arg1)->hasCompileError();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.reset_compile_error

  call-seq:
    reset_compile_error

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_reset_compile_error(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);
  {
    try {
      (arg1)->resetCompileError();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.set_manual_named_constants

  call-seq:
    set_manual_named_constants(GpuNamedConstants namedConstants)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_set_manual_named_constants(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);
  {
    try {
      (arg1)->setManualNamedConstants((Ogre::GpuNamedConstants const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_named_constants

  call-seq:
    get_named_constants -> GpuNamedConstants

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_named_constants(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);
  {
    try {
      result = (Ogre::GpuNamedConstants *) &((Ogre::GpuProgram const *)arg1)->getNamedConstants();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.set_manual_named_constants_file

  call-seq:
    set_manual_named_constants_file(String paramDefFile)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_set_manual_named_constants_file(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;
  }
  {
    try {
      (arg1)->setManualNamedConstantsFile((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_manual_named_constants_file

  call-seq:
    get_manual_named_constants_file -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_manual_named_constants_file(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::GpuProgram const *)arg1)->getManualNamedConstantsFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgram.get_constant_definitions

  call-seq:
    get_constant_definitions -> GpuNamedConstants

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgram_get_constant_definitions(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);
  {
    try {
      result = (Ogre::GpuNamedConstants *) &((Ogre::GpuProgram const *)arg1)->getConstantDefinitions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::GpuProgramPtr

  Proxy of C++ Ogre::GpuProgramPtr class


*/
swig_class SwigClassGpuProgramPtr;


/*
  Document-method: Ogre::GpuProgramPtr.new

  call-seq:
    GpuProgramPtr.new
    GpuProgramPtr.new(GpuProgram rep)
    GpuProgramPtr.new(GpuProgramPtr r)
    GpuProgramPtr.new(ResourcePtr r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::GpuProgramPtr *)new Ogre::GpuProgramPtr();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::GpuProgramPtr *)new Ogre::GpuProgramPtr(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::GpuProgramPtr *)new Ogre::GpuProgramPtr((Ogre::GpuProgramPtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::GpuProgramPtr *)new Ogre::GpuProgramPtr((Ogre::ResourcePtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::UserObjectBindings

  Proxy of C++ Ogre::UserObjectBindings class


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


/*
  Document-method: Ogre::UserObjectBindings.new

  call-seq:
    UserObjectBindings.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::UserObjectBindings *)new Ogre::UserObjectBindings();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_UserObjectBindings(Ogre::UserObjectBindings *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::UserObjectBindings.set_user_any

  call-seq:
    set_user_any(Any anything)
    set_user_any(String key, Any anything)

An instance method.

*/
SWIGINTERN VALUE
_wrap_UserObjectBindings_set_user_any__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);
  {
    try {
      (arg1)->setUserAny((Ogre::Any const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UserObjectBindings.get_user_any

  call-seq:
    get_user_any -> Any
    get_user_any(String key) -> Any

An instance method.

*/
SWIGINTERN VALUE
_wrap_UserObjectBindings_get_user_any__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);
  {
    try {
      result = (Ogre::Any *) &((Ogre::UserObjectBindings const *)arg1)->getUserAny();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UserObjectBindings.set_user_any

  call-seq:
    set_user_any(Any anything)
    set_user_any(String key, Any anything)

An instance method.

*/
SWIGINTERN VALUE
_wrap_UserObjectBindings_set_user_any__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);
  {
    try {
      (arg1)->setUserAny((Ogre::String const &)*arg2,(Ogre::Any const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_UserObjectBindings_set_user_any(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_set_user_any__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_set_user_any__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "UserObjectBindings.set_user_any", 
    "    void UserObjectBindings.set_user_any(Ogre::Any const &anything)\n"
    "    void UserObjectBindings.set_user_any(Ogre::String const &key, Ogre::Any const &anything)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UserObjectBindings.get_user_any

  call-seq:
    get_user_any -> Any
    get_user_any(String key) -> Any

An instance method.

*/
SWIGINTERN VALUE
_wrap_UserObjectBindings_get_user_any__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;
  }
  {
    try {
      result = (Ogre::Any *) &((Ogre::UserObjectBindings const *)arg1)->getUserAny((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_user_any(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_get_user_any__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_get_user_any__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "UserObjectBindings.get_user_any", 
    "    Ogre::Any const & UserObjectBindings.get_user_any()\n"
    "    Ogre::Any const & UserObjectBindings.get_user_any(Ogre::String const &key)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UserObjectBindings.erase_user_any

  call-seq:
    erase_user_any(String key)

An instance method.

*/
SWIGINTERN VALUE
_wrap_UserObjectBindings_erase_user_any(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;
  }
  {
    try {
      (arg1)->eraseUserAny((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  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);
  {
    try {
      ((Ogre::UserObjectBindings const *)arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UserObjectBindings.get_empty_user_any

  call-seq:
    get_empty_user_any -> Any

A class method.

*/
SWIGINTERN VALUE
_wrap_UserObjectBindings_get_empty_user_any(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;
  }
  {
    try {
      result = (Ogre::Any *) &Ogre::UserObjectBindings::getEmptyUserAny();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Renderable

  Proxy of C++ Ogre::Renderable class


*/
swig_class SwigClassRenderable;

SWIGINTERN void
free_Ogre_Renderable(Ogre::Renderable *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Renderable.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::Renderable const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_technique

  call-seq:
    get_technique -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_technique(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);
  {
    try {
      result = (Ogre::Technique *)((Ogre::Renderable const *)arg1)->getTechnique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_render_operation

  call-seq:
    get_render_operation(RenderOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_render_operation(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);
  {
    try {
      (arg1)->getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.pre_render

  call-seq:
    pre_render(SceneManager sm, RenderSystem rsys) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_pre_render(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);
  {
    try {
      result = (bool)(arg1)->preRender(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.post_render

  call-seq:
    post_render(SceneManager sm, RenderSystem rsys)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_post_render(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);
  {
    try {
      (arg1)->postRender(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_world_transforms(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);
  {
    try {
      ((Ogre::Renderable const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_num_world_transforms

  call-seq:
    get_num_world_transforms -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_num_world_transforms(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);
  {
    try {
      result = (unsigned short)((Ogre::Renderable const *)arg1)->getNumWorldTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.set_use_identity_projection

  call-seq:
    set_use_identity_projection(bool useIdentityProjection)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_set_use_identity_projection(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);
  {
    try {
      (arg1)->setUseIdentityProjection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_use_identity_projection

  call-seq:
    get_use_identity_projection -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_use_identity_projection(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);
  {
    try {
      result = (bool)((Ogre::Renderable const *)arg1)->getUseIdentityProjection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.set_use_identity_view

  call-seq:
    set_use_identity_view(bool useIdentityView)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_set_use_identity_view(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);
  {
    try {
      (arg1)->setUseIdentityView(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_use_identity_view

  call-seq:
    get_use_identity_view -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_use_identity_view(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);
  {
    try {
      result = (bool)((Ogre::Renderable const *)arg1)->getUseIdentityView();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera cam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Renderable const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_lights

  call-seq:
    get_lights -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_lights(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::Renderable const *)arg1)->getLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_casts_shadows

  call-seq:
    get_casts_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_casts_shadows(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);
  {
    try {
      result = (bool)((Ogre::Renderable const *)arg1)->getCastsShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.set_custom_parameter

  call-seq:
    set_custom_parameter(size_t index, Vector4 value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_set_custom_parameter(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);
  {
    try {
      (arg1)->setCustomParameter(arg2,(Ogre::Vector4 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.remove_custom_parameter

  call-seq:
    remove_custom_parameter(size_t index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_remove_custom_parameter(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);
  {
    try {
      (arg1)->removeCustomParameter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.has_custom_parameter

  call-seq:
    has_custom_parameter(size_t index) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_has_custom_parameter(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);
  {
    try {
      result = (bool)((Ogre::Renderable const *)arg1)->hasCustomParameter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_custom_parameter

  call-seq:
    get_custom_parameter(size_t index) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_custom_parameter(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);
  {
    try {
      result = (Ogre::Vector4 *) &((Ogre::Renderable const *)arg1)->getCustomParameter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable._update_custom_gpu_parameter

  call-seq:
    _update_custom_gpu_parameter(AutoConstantEntry constantEntry, GpuProgramParameters params)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable__update_custom_gpu_parameter(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);
  {
    try {
      ((Ogre::Renderable const *)arg1)->_updateCustomGpuParameter((Ogre::GpuProgramParameters::AutoConstantEntry const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.set_polygon_mode_overrideable

  call-seq:
    set_polygon_mode_overrideable(bool override)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_set_polygon_mode_overrideable(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);
  {
    try {
      (arg1)->setPolygonModeOverrideable(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_polygon_mode_overrideable

  call-seq:
    get_polygon_mode_overrideable -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_polygon_mode_overrideable(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);
  {
    try {
      result = (bool)((Ogre::Renderable const *)arg1)->getPolygonModeOverrideable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.set_user_any

  call-seq:
    set_user_any(Any anything)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_set_user_any(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);
  {
    try {
      (arg1)->setUserAny((Ogre::Any const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_user_any

  call-seq:
    get_user_any -> Any

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_user_any(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);
  {
    try {
      result = (Ogre::Any *) &((Ogre::Renderable const *)arg1)->getUserAny();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_user_object_bindings

  call-seq:
    get_user_object_bindings -> UserObjectBindings
    get_user_object_bindings -> UserObjectBindings

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_user_object_bindings__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);
  {
    try {
      result = (Ogre::UserObjectBindings *) &(arg1)->getUserObjectBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_get_user_object_bindings__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);
  {
    try {
      result = (Ogre::UserObjectBindings *) &((Ogre::Renderable const *)arg1)->getUserObjectBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Renderable_get_user_object_bindings(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_get_user_object_bindings__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_get_user_object_bindings__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Renderable.get_user_object_bindings", 
    "    Ogre::UserObjectBindings const & Renderable.get_user_object_bindings()\n"
    "    Ogre::UserObjectBindings const & Renderable.get_user_object_bindings()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.get_render_system_data

  call-seq:
    get_render_system_data -> RenderSystemData

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_get_render_system_data(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);
  {
    try {
      result = (Ogre::Renderable::RenderSystemData *)((Ogre::Renderable const *)arg1)->getRenderSystemData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Renderable__RenderSystemData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Renderable.set_render_system_data

  call-seq:
    set_render_system_data(RenderSystemData val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Renderable_set_render_system_data(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);
  {
    try {
      ((Ogre::Renderable const *)arg1)->setRenderSystemData(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ShadowRenderable < Ogre::Ogre::Renderable

  Proxy of C++ Ogre::ShadowRenderable class


*/
swig_class SwigClassShadowRenderable;

SWIGINTERN void
free_Ogre_ShadowRenderable(Ogre::ShadowRenderable *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ShadowRenderable.set_material

  call-seq:
    set_material(MaterialPtr mat)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowRenderable_set_material(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);
  {
    try {
      (arg1)->setMaterial((Ogre::MaterialPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowRenderable.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowRenderable_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::ShadowRenderable const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowRenderable.get_render_operation

  call-seq:
    get_render_operation(RenderOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowRenderable_get_render_operation(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);
  {
    try {
      (arg1)->getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowRenderable.get_render_operation_for_update

  call-seq:
    get_render_operation_for_update -> RenderOperation

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowRenderable_get_render_operation_for_update(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);
  {
    try {
      result = (Ogre::RenderOperation *)(arg1)->getRenderOperationForUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderOperation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowRenderable.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowRenderable_get_world_transforms(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);
  {
    try {
      ((Ogre::ShadowRenderable const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowRenderable.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera ?) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowRenderable_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ShadowRenderable const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowRenderable.get_lights

  call-seq:
    get_lights -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowRenderable_get_lights(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::ShadowRenderable const *)arg1)->getLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowRenderable.is_light_cap_separate

  call-seq:
    is_light_cap_separate -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowRenderable_is_light_cap_separate(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);
  {
    try {
      result = (bool)((Ogre::ShadowRenderable const *)arg1)->isLightCapSeparate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowRenderable.get_light_cap_renderable

  call-seq:
    get_light_cap_renderable -> ShadowRenderable

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowRenderable_get_light_cap_renderable(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);
  {
    try {
      result = (Ogre::ShadowRenderable *)(arg1)->getLightCapRenderable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ShadowRenderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowRenderable.is_visible

  call-seq:
    is_visible -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowRenderable_is_visible(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);
  {
    try {
      result = (bool)((Ogre::ShadowRenderable const *)arg1)->isVisible();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowRenderable.rebind_index_buffer

  call-seq:
    rebind_index_buffer(HardwareIndexBufferSharedPtr indexBuffer)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowRenderable_rebind_index_buffer(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);
  {
    try {
      (arg1)->rebindIndexBuffer((Ogre::HardwareIndexBufferSharedPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ShadowCaster

  Proxy of C++ Ogre::ShadowCaster class


*/
swig_class SwigClassShadowCaster;

SWIGINTERN void
free_Ogre_ShadowCaster(Ogre::ShadowCaster *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ShadowCaster.get_cast_shadows

  call-seq:
    get_cast_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowCaster_get_cast_shadows(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);
  {
    try {
      result = (bool)((Ogre::ShadowCaster const *)arg1)->getCastShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowCaster.get_edge_list

  call-seq:
    get_edge_list -> EdgeData

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowCaster_get_edge_list(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);
  {
    try {
      result = (Ogre::EdgeData *)(arg1)->getEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowCaster.has_edge_list

  call-seq:
    has_edge_list -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowCaster_has_edge_list(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);
  {
    try {
      result = (bool)(arg1)->hasEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowCaster.get_world_bounding_box

  call-seq:
    get_world_bounding_box(bool derive=false) -> AxisAlignedBox
    get_world_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowCaster_get_world_bounding_box__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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::ShadowCaster const *)arg1)->getWorldBoundingBox(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowCaster_get_world_bounding_box__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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::ShadowCaster const *)arg1)->getWorldBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ShadowCaster_get_world_bounding_box(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_get_world_bounding_box__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_get_world_bounding_box__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ShadowCaster.get_world_bounding_box", 
    "    Ogre::AxisAlignedBox const & ShadowCaster.get_world_bounding_box(bool derive)\n"
    "    Ogre::AxisAlignedBox const & ShadowCaster.get_world_bounding_box()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ShadowCaster.get_light_cap_bounds

  call-seq:
    get_light_cap_bounds -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowCaster_get_light_cap_bounds(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::ShadowCaster const *)arg1)->getLightCapBounds();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowCaster.get_dark_cap_bounds

  call-seq:
    get_dark_cap_bounds(Light light, Real dirLightExtrusionDist) -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowCaster_get_dark_cap_bounds(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::ShadowCaster const *)arg1)->getDarkCapBounds((Ogre::Light const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowCaster.get_shadow_volume_renderable_iterator

  call-seq:
    get_shadow_volume_renderable_iterator(ShadowTechnique shadowTechnique, Light light, HardwareIndexBufferSharedPtr indexBuffer, 
    bool extrudeVertices, 
    Real extrusionDistance, unsigned long flags=0) -> ShadowRenderableListIterator
    get_shadow_volume_renderable_iterator(ShadowTechnique shadowTechnique, Light light, HardwareIndexBufferSharedPtr indexBuffer, 
    bool extrudeVertices, 
    Real extrusionDistance) -> ShadowRenderableListIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowCaster_get_shadow_volume_renderable_iterator__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);
  {
    try {
      result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_shadow_volume_renderable_iterator__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);
  {
    try {
      result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_shadow_volume_renderable_iterator(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_get_shadow_volume_renderable_iterator__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_get_shadow_volume_renderable_iterator__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "ShadowCaster.get_shadow_volume_renderable_iterator", 
    "    Ogre::ShadowCaster::ShadowRenderableListIterator ShadowCaster.get_shadow_volume_renderable_iterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDistance, unsigned long flags)\n"
    "    Ogre::ShadowCaster::ShadowRenderableListIterator ShadowCaster.get_shadow_volume_renderable_iterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDistance)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ShadowCaster.extrude_vertices

  call-seq:
    extrude_vertices(HardwareVertexBufferSharedPtr vertexBuffer, size_t originalVertexCount, 
    Vector4 lightPos, Real extrudeDist)

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowCaster_extrude_vertices(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);
  {
    try {
      Ogre::ShadowCaster::extrudeVertices((Ogre::HardwareVertexBufferSharedPtr const &)*arg1,arg2,(Ogre::Vector4 const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowCaster.get_point_extrusion_distance

  call-seq:
    get_point_extrusion_distance(Light l) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowCaster_get_point_extrusion_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ShadowCaster const *)arg1)->getPointExtrusionDistance((Ogre::Light const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::MovableObject < Ogre::Ogre::ShadowCaster, Ogre::Ogre::AnimableObject

  Proxy of C++ Ogre::MovableObject class


*/
swig_class SwigClassMovableObject;

SWIGINTERN void
free_Ogre_MovableObject(Ogre::MovableObject *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::MovableObject._notify_creator

  call-seq:
    _notify_creator(MovableObjectFactory fact)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject__notify_creator(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);
  {
    try {
      (arg1)->_notifyCreator(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject._get_creator

  call-seq:
    _get_creator -> MovableObjectFactory

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject__get_creator(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);
  {
    try {
      result = (Ogre::MovableObjectFactory *)((Ogre::MovableObject const *)arg1)->_getCreator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObjectFactory, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject._notify_manager

  call-seq:
    _notify_manager(SceneManager man)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject__notify_manager(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);
  {
    try {
      (arg1)->_notifyManager(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject._get_manager

  call-seq:
    _get_manager -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject__get_manager(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);
  {
    try {
      result = (Ogre::SceneManager *)((Ogre::MovableObject const *)arg1)->_getManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::MovableObject const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::MovableObject const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_parent_node

  call-seq:
    get_parent_node -> Node

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_parent_node(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);
  {
    try {
      result = (Ogre::Node *)((Ogre::MovableObject const *)arg1)->getParentNode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_parent_scene_node

  call-seq:
    get_parent_scene_node -> SceneNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_parent_scene_node(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);
  {
    try {
      result = (Ogre::SceneNode *)((Ogre::MovableObject const *)arg1)->getParentSceneNode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.is_parent_tag_point

  call-seq:
    is_parent_tag_point -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_is_parent_tag_point(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);
  {
    try {
      result = (bool)((Ogre::MovableObject const *)arg1)->isParentTagPoint();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject._notify_attached

  call-seq:
    _notify_attached(Node parent, bool isTagPoint=false)
    _notify_attached(Node parent)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovableObject__notify_attached(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__notify_attached__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__notify_attached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MovableObject._notify_attached", 
    "    void MovableObject._notify_attached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void MovableObject._notify_attached(Ogre::Node *parent)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.is_attached

  call-seq:
    is_attached -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_is_attached(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);
  {
    try {
      result = (bool)((Ogre::MovableObject const *)arg1)->isAttached();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.detach_from_parent

  call-seq:
    detach_from_parent

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_detach_from_parent(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);
  {
    try {
      (arg1)->detachFromParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.is_in_scene

  call-seq:
    is_in_scene -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_is_in_scene(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);
  {
    try {
      result = (bool)((Ogre::MovableObject const *)arg1)->isInScene();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject._notify_moved

  call-seq:
    _notify_moved

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject__notify_moved(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);
  {
    try {
      (arg1)->_notifyMoved();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject._notify_current_camera

  call-seq:
    _notify_current_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject__notify_current_camera(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);
  {
    try {
      (arg1)->_notifyCurrentCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::MovableObject const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::MovableObject const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_world_bounding_box

  call-seq:
    get_world_bounding_box(bool derive=false) -> AxisAlignedBox
    get_world_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_world_bounding_box__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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::MovableObject const *)arg1)->getWorldBoundingBox(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_get_world_bounding_box__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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::MovableObject const *)arg1)->getWorldBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovableObject_get_world_bounding_box(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_get_world_bounding_box__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_get_world_bounding_box__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "MovableObject.get_world_bounding_box", 
    "    Ogre::AxisAlignedBox const & MovableObject.get_world_bounding_box(bool derive)\n"
    "    Ogre::AxisAlignedBox const & MovableObject.get_world_bounding_box()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_world_bounding_sphere

  call-seq:
    get_world_bounding_sphere(bool derive=false) -> Sphere
    get_world_bounding_sphere -> Sphere

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_world_bounding_sphere__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);
  {
    try {
      result = (Ogre::Sphere *) &((Ogre::MovableObject const *)arg1)->getWorldBoundingSphere(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_get_world_bounding_sphere__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);
  {
    try {
      result = (Ogre::Sphere *) &((Ogre::MovableObject const *)arg1)->getWorldBoundingSphere();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovableObject_get_world_bounding_sphere(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_get_world_bounding_sphere__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_get_world_bounding_sphere__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "MovableObject.get_world_bounding_sphere", 
    "    Ogre::Sphere const & MovableObject.get_world_bounding_sphere(bool derive)\n"
    "    Ogre::Sphere const & MovableObject.get_world_bounding_sphere()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_visible

  call-seq:
    set_visible(bool visible)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_visible(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);
  {
    try {
      (arg1)->setVisible(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_visible

  call-seq:
    get_visible -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_visible(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);
  {
    try {
      result = (bool)((Ogre::MovableObject const *)arg1)->getVisible();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.is_visible

  call-seq:
    is_visible -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_is_visible(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);
  {
    try {
      result = (bool)((Ogre::MovableObject const *)arg1)->isVisible();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_rendering_distance

  call-seq:
    set_rendering_distance(Real dist)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_rendering_distance(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);
  {
    try {
      (arg1)->setRenderingDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_rendering_distance

  call-seq:
    get_rendering_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_rendering_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::MovableObject const *)arg1)->getRenderingDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_rendering_min_pixel_size

  call-seq:
    set_rendering_min_pixel_size(Real pixelSize)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_rendering_min_pixel_size(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);
  {
    try {
      (arg1)->setRenderingMinPixelSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_rendering_min_pixel_size

  call-seq:
    get_rendering_min_pixel_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_rendering_min_pixel_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::MovableObject const *)arg1)->getRenderingMinPixelSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_user_any

  call-seq:
    set_user_any(Any anything)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_user_any(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);
  {
    try {
      (arg1)->setUserAny((Ogre::Any const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_user_any

  call-seq:
    get_user_any -> Any

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_user_any(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);
  {
    try {
      result = (Ogre::Any *) &((Ogre::MovableObject const *)arg1)->getUserAny();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_user_object_bindings

  call-seq:
    get_user_object_bindings -> UserObjectBindings
    get_user_object_bindings -> UserObjectBindings

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_user_object_bindings__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);
  {
    try {
      result = (Ogre::UserObjectBindings *) &(arg1)->getUserObjectBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_get_user_object_bindings__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);
  {
    try {
      result = (Ogre::UserObjectBindings *) &((Ogre::MovableObject const *)arg1)->getUserObjectBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovableObject_get_user_object_bindings(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_get_user_object_bindings__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_get_user_object_bindings__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "MovableObject.get_user_object_bindings", 
    "    Ogre::UserObjectBindings const & MovableObject.get_user_object_bindings()\n"
    "    Ogre::UserObjectBindings const & MovableObject.get_user_object_bindings()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_render_queue_group

  call-seq:
    set_render_queue_group(uint8 queueID)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_render_queue_group(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);
  {
    try {
      (arg1)->setRenderQueueGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_render_queue_group_and_priority

  call-seq:
    set_render_queue_group_and_priority(uint8 queueID, ushort priority)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_render_queue_group_and_priority(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);
  {
    try {
      (arg1)->setRenderQueueGroupAndPriority(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_render_queue_group

  call-seq:
    get_render_queue_group -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_render_queue_group(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::MovableObject const *)arg1)->getRenderQueueGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject._get_parent_node_full_transform

  call-seq:
    _get_parent_node_full_transform -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject__get_parent_node_full_transform(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::MovableObject const *)arg1)->_getParentNodeFullTransform();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_query_flags

  call-seq:
    set_query_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_query_flags(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);
  {
    try {
      (arg1)->setQueryFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.add_query_flags

  call-seq:
    add_query_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_add_query_flags(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);
  {
    try {
      (arg1)->addQueryFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.remove_query_flags

  call-seq:
    remove_query_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_remove_query_flags(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);
  {
    try {
      (arg1)->removeQueryFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_query_flags

  call-seq:
    get_query_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_query_flags(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::MovableObject const *)arg1)->getQueryFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_default_query_flags

  call-seq:
    set_default_query_flags(uint32 flags)

A class method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_default_query_flags(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);
  {
    try {
      Ogre::MovableObject::setDefaultQueryFlags(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_default_query_flags

  call-seq:
    get_default_query_flags -> uint32

A class method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_default_query_flags(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;
  }
  {
    try {
      result = (Ogre::uint32)Ogre::MovableObject::getDefaultQueryFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_visibility_flags

  call-seq:
    set_visibility_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_visibility_flags(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);
  {
    try {
      (arg1)->setVisibilityFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.add_visibility_flags

  call-seq:
    add_visibility_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_add_visibility_flags(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);
  {
    try {
      (arg1)->addVisibilityFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.remove_visibility_flags

  call-seq:
    remove_visibility_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_remove_visibility_flags(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);
  {
    try {
      (arg1)->removeVisibilityFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_visibility_flags

  call-seq:
    get_visibility_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_visibility_flags(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::MovableObject const *)arg1)->getVisibilityFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_default_visibility_flags

  call-seq:
    set_default_visibility_flags(uint32 flags)

A class method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_default_visibility_flags(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);
  {
    try {
      Ogre::MovableObject::setDefaultVisibilityFlags(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_default_visibility_flags

  call-seq:
    get_default_visibility_flags -> uint32

A class method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_default_visibility_flags(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;
  }
  {
    try {
      result = (Ogre::uint32)Ogre::MovableObject::getDefaultVisibilityFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_listener

  call-seq:
    set_listener(Listener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_listener(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);
  {
    try {
      (arg1)->setListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_listener

  call-seq:
    get_listener -> Listener

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_listener(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);
  {
    try {
      result = (Ogre::MovableObject::Listener *)((Ogre::MovableObject const *)arg1)->getListener();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject__Listener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.query_lights

  call-seq:
    query_lights -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_query_lights(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::MovableObject const *)arg1)->queryLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_light_mask

  call-seq:
    get_light_mask -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_light_mask(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::MovableObject const *)arg1)->getLightMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_light_mask

  call-seq:
    set_light_mask(uint32 lightMask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_light_mask(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);
  {
    try {
      (arg1)->setLightMask(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject._get_light_list

  call-seq:
    _get_light_list -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject__get_light_list(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);
  {
    try {
      result = (Ogre::LightList *)(arg1)->_getLightList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_edge_list

  call-seq:
    get_edge_list -> EdgeData

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_edge_list(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);
  {
    try {
      result = (Ogre::EdgeData *)(arg1)->getEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.has_edge_list

  call-seq:
    has_edge_list -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_has_edge_list(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);
  {
    try {
      result = (bool)(arg1)->hasEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_shadow_volume_renderable_iterator

  call-seq:
    get_shadow_volume_renderable_iterator(ShadowTechnique shadowTechnique, Light light, HardwareIndexBufferSharedPtr indexBuffer, 
    bool extrudeVertices, 
    Real extrusionDist, unsigned long flags=0) -> ShadowRenderableListIterator
    get_shadow_volume_renderable_iterator(ShadowTechnique shadowTechnique, Light light, HardwareIndexBufferSharedPtr indexBuffer, 
    bool extrudeVertices, 
    Real extrusionDist) -> ShadowRenderableListIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_shadow_volume_renderable_iterator__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);
  {
    try {
      result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_shadow_volume_renderable_iterator__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);
  {
    try {
      result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_shadow_volume_renderable_iterator(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_get_shadow_volume_renderable_iterator__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_get_shadow_volume_renderable_iterator__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "MovableObject.get_shadow_volume_renderable_iterator", 
    "    Ogre::ShadowCaster::ShadowRenderableListIterator MovableObject.get_shadow_volume_renderable_iterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDist, unsigned long flags)\n"
    "    Ogre::ShadowCaster::ShadowRenderableListIterator MovableObject.get_shadow_volume_renderable_iterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDist)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_light_cap_bounds

  call-seq:
    get_light_cap_bounds -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_light_cap_bounds(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::MovableObject const *)arg1)->getLightCapBounds();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_dark_cap_bounds

  call-seq:
    get_dark_cap_bounds(Light light, Real dirLightExtrusionDist) -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_dark_cap_bounds(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::MovableObject const *)arg1)->getDarkCapBounds((Ogre::Light const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_cast_shadows

  call-seq:
    set_cast_shadows(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_cast_shadows(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);
  {
    try {
      (arg1)->setCastShadows(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_cast_shadows

  call-seq:
    get_cast_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_cast_shadows(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);
  {
    try {
      result = (bool)((Ogre::MovableObject const *)arg1)->getCastShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_receives_shadows

  call-seq:
    get_receives_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_receives_shadows(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);
  {
    try {
      result = (bool)(arg1)->getReceivesShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_point_extrusion_distance

  call-seq:
    get_point_extrusion_distance(Light l) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_point_extrusion_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::MovableObject const *)arg1)->getPointExtrusionDistance((Ogre::Light const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.get_type_flags

  call-seq:
    get_type_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_get_type_flags(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::MovableObject const *)arg1)->getTypeFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovableObject_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MovableObject.visit_renderables", 
    "    void MovableObject.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void MovableObject.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.set_debug_display_enabled

  call-seq:
    set_debug_display_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_set_debug_display_enabled(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);
  {
    try {
      (arg1)->setDebugDisplayEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObject.is_debug_display_enabled

  call-seq:
    is_debug_display_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObject_is_debug_display_enabled(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);
  {
    try {
      result = (bool)((Ogre::MovableObject const *)arg1)->isDebugDisplayEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::MovableObjectFactory

  Proxy of C++ Ogre::MovableObjectFactory class


*/
swig_class SwigClassMovableObjectFactory;

SWIGINTERN void
free_Ogre_MovableObjectFactory(Ogre::MovableObjectFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::MovableObjectFactory.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObjectFactory_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::MovableObjectFactory const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObjectFactory.create_instance

  call-seq:
    create_instance(String name, SceneManager manager, NameValuePairList params=0) -> MovableObject
    create_instance(String name, SceneManager manager) -> MovableObject

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObjectFactory_create_instance__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);
  {
    try {
      result = (Ogre::MovableObject *)(arg1)->createInstance((Ogre::String const &)*arg2,arg3,(Ogre::NameValuePairList const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_instance__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);
  {
    try {
      result = (Ogre::MovableObject *)(arg1)->createInstance((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_instance(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_create_instance__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_create_instance__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MovableObjectFactory.create_instance", 
    "    Ogre::MovableObject * MovableObjectFactory.create_instance(Ogre::String const &name, Ogre::SceneManager *manager, Ogre::NameValuePairList const *params)\n"
    "    Ogre::MovableObject * MovableObjectFactory.create_instance(Ogre::String const &name, Ogre::SceneManager *manager)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MovableObjectFactory.destroy_instance

  call-seq:
    destroy_instance(MovableObject obj)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObjectFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObjectFactory.request_type_flags

  call-seq:
    request_type_flags -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObjectFactory_request_type_flags(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);
  {
    try {
      result = (bool)((Ogre::MovableObjectFactory const *)arg1)->requestTypeFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObjectFactory._notify_type_flags

  call-seq:
    _notify_type_flags(unsigned long flag)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObjectFactory__notify_type_flags(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);
  {
    try {
      (arg1)->_notifyTypeFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovableObjectFactory.get_type_flags

  call-seq:
    get_type_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovableObjectFactory_get_type_flags(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::MovableObjectFactory const *)arg1)->getTypeFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PlaneBoundedVolume

  Proxy of C++ Ogre::PlaneBoundedVolume class


*/
swig_class SwigClassPlaneBoundedVolume;


/*
  Document-method: Ogre::PlaneBoundedVolume.planes

  call-seq:
    planes -> PlaneList

Get value of attribute.

*/

/*
  Document-method: Ogre::PlaneBoundedVolume.planes=

  call-seq:
    planes=(x) -> PlaneList

Set new value for attribute.

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



/*
  Document-method: Ogre::PlaneBoundedVolume.outside

  call-seq:
    outside -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::PlaneBoundedVolume.outside=

  call-seq:
    outside=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::PlaneBoundedVolume.new

  call-seq:
    PlaneBoundedVolume.new
    PlaneBoundedVolume.new(Side theOutside)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PlaneBoundedVolume *)new Ogre::PlaneBoundedVolume();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::PlaneBoundedVolume *)new Ogre::PlaneBoundedVolume(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::PlaneBoundedVolume.intersects

  call-seq:
    intersects(AxisAlignedBox box) -> bool
    intersects(Sphere sphere) -> bool
    intersects(Ray ray) -> std::pair<(bool,Ogre::Real)>

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::PlaneBoundedVolume const *)arg1)->intersects((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (bool)((Ogre::PlaneBoundedVolume const *)arg1)->intersects((Ogre::Sphere const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (arg1)->intersects((Ogre::Ray const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
}


/*
  Document-class: Ogre::MovablePlane < Ogre::Ogre::Plane, Ogre::Ogre::MovableObject

  Proxy of C++ Ogre::MovablePlane class


*/
swig_class SwigClassMovablePlane;


/*
  Document-method: Ogre::MovablePlane.new

  call-seq:
    MovablePlane.new(String name)
    MovablePlane.new(Plane rhs)
    MovablePlane.new(Vector3 rkNormal, Real fConstant)
    MovablePlane.new(Vector3 rkNormal, Vector3 rkPoint)
    MovablePlane.new(Vector3 rkPoint0, Vector3 rkPoint1, Vector3 rkPoint2)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::MovablePlane *)new Ogre::MovablePlane((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::MovablePlane *)new Ogre::MovablePlane((Ogre::Plane const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MovablePlane *)new Ogre::MovablePlane((Ogre::Vector3 const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MovablePlane *)new Ogre::MovablePlane((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::MovablePlane *)new Ogre::MovablePlane((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::MovablePlane._notify_current_camera

  call-seq:
    _notify_current_camera(Camera ?)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovablePlane__notify_current_camera(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);
  {
    try {
      (arg1)->_notifyCurrentCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovablePlane.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovablePlane_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::MovablePlane const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovablePlane.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovablePlane_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::MovablePlane const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovablePlane._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue ?)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovablePlane__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovablePlane.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovablePlane_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::MovablePlane const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovablePlane._get_derived_plane

  call-seq:
    _get_derived_plane -> Plane

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovablePlane__get_derived_plane(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);
  {
    try {
      result = (Ogre::Plane *) &((Ogre::MovablePlane const *)arg1)->_getDerivedPlane();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MovablePlane.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MovablePlane_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovablePlane_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovablePlane_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MovablePlane.visit_renderables", 
    "    void MovablePlane.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void MovablePlane.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::ShadowCameraSetup

  Proxy of C++ Ogre::ShadowCameraSetup class


*/
swig_class SwigClassShadowCameraSetup;


/*
  Document-method: Ogre::ShadowCameraSetup.get_shadow_camera

  call-seq:
    get_shadow_camera(SceneManager sm, Camera cam, Viewport vp, Light light, 
    Camera texCam, size_t iteration)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowCameraSetup_get_shadow_camera(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);
  {
    try {
      ((Ogre::ShadowCameraSetup const *)arg1)->getShadowCamera((Ogre::SceneManager const *)arg2,(Ogre::Camera const *)arg3,(Ogre::Viewport const *)arg4,(Ogre::Light const *)arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ShadowCameraSetup(Ogre::ShadowCameraSetup *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::DefaultShadowCameraSetup < Ogre::Ogre::ShadowCameraSetup

  Proxy of C++ Ogre::DefaultShadowCameraSetup class


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


/*
  Document-method: Ogre::DefaultShadowCameraSetup.new

  call-seq:
    DefaultShadowCameraSetup.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::DefaultShadowCameraSetup *)new Ogre::DefaultShadowCameraSetup();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultShadowCameraSetup(Ogre::DefaultShadowCameraSetup *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DefaultShadowCameraSetup.get_shadow_camera

  call-seq:
    get_shadow_camera(SceneManager sm, Camera cam, Viewport vp, Light light, 
    Camera texCam, size_t iteration)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultShadowCameraSetup_get_shadow_camera(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);
  {
    try {
      ((Ogre::DefaultShadowCameraSetup const *)arg1)->getShadowCamera((Ogre::SceneManager const *)arg2,(Ogre::Camera const *)arg3,(Ogre::Viewport const *)arg4,(Ogre::Light const *)arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Light < Ogre::Ogre::MovableObject

  Proxy of C++ Ogre::Light class


*/
swig_class SwigClassLight;


/*
  Document-method: Ogre::Light.tempSquareDist

  call-seq:
    tempSquareDist -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Light.tempSquareDist=

  call-seq:
    tempSquareDist=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::Light._calc_temp_square_dist

  call-seq:
    _calc_temp_square_dist(Vector3 worldPos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light__calc_temp_square_dist(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);
  {
    try {
      (arg1)->_calcTempSquareDist((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LightTypes.LT_POINT

  call-seq:
    LT_POINT -> int

A class method.

*/

/*
  Document-method: Ogre::LightTypes.LT_DIRECTIONAL

  call-seq:
    LT_DIRECTIONAL -> int

A class method.

*/

/*
  Document-method: Ogre::LightTypes.LT_SPOTLIGHT

  call-seq:
    LT_SPOTLIGHT -> int

A class method.

*/

/*
  Document-method: Ogre::Light.new

  call-seq:
    Light.new
    Light.new(String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Light *)new Ogre::Light();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      result = (Ogre::Light *)new Ogre::Light((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::Light.set_type

  call-seq:
    set_type(LightTypes type)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_type(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);
  {
    try {
      (arg1)->setType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_type

  call-seq:
    get_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_type(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);
  {
    try {
      result = (Ogre::Light::LightTypes)((Ogre::Light const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_diffuse_colour

  call-seq:
    set_diffuse_colour(Real red, Real green, Real blue)
    set_diffuse_colour(ColourValue colour)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_diffuse_colour__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);
  {
    try {
      (arg1)->setDiffuseColour(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_set_diffuse_colour__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);
  {
    try {
      (arg1)->setDiffuseColour((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_set_diffuse_colour(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_set_diffuse_colour__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_set_diffuse_colour__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Light.set_diffuse_colour", 
    "    void Light.set_diffuse_colour(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Light.set_diffuse_colour(Ogre::ColourValue const &colour)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_diffuse_colour

  call-seq:
    get_diffuse_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_diffuse_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::Light const *)arg1)->getDiffuseColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_specular_colour

  call-seq:
    set_specular_colour(Real red, Real green, Real blue)
    set_specular_colour(ColourValue colour)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_specular_colour__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);
  {
    try {
      (arg1)->setSpecularColour(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_set_specular_colour__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);
  {
    try {
      (arg1)->setSpecularColour((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_set_specular_colour(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_set_specular_colour__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_set_specular_colour__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Light.set_specular_colour", 
    "    void Light.set_specular_colour(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Light.set_specular_colour(Ogre::ColourValue const &colour)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_specular_colour

  call-seq:
    get_specular_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_specular_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::Light const *)arg1)->getSpecularColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_attenuation

  call-seq:
    set_attenuation(Real range, Real constant, Real linear, Real quadratic)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_attenuation(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);
  {
    try {
      (arg1)->setAttenuation(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_attenuation_range

  call-seq:
    get_attenuation_range -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_attenuation_range(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->getAttenuationRange();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_attenuation_constant

  call-seq:
    get_attenuation_constant -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_attenuation_constant(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->getAttenuationConstant();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_attenuation_linear

  call-seq:
    get_attenuation_linear -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_attenuation_linear(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->getAttenuationLinear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_attenuation_quadric

  call-seq:
    get_attenuation_quadric -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_attenuation_quadric(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->getAttenuationQuadric();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_position

  call-seq:
    set_position(Real x, Real y, Real z)
    set_position(Vector3 vec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_position__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);
  {
    try {
      (arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_set_position__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);
  {
    try {
      (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_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_set_position__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_set_position__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Light.set_position", 
    "    void Light.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    void Light.set_position(Ogre::Vector3 const &vec)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_position

  call-seq:
    get_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Light const *)arg1)->getPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_direction

  call-seq:
    set_direction(Real x, Real y, Real z)
    set_direction(Vector3 vec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_direction__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);
  {
    try {
      (arg1)->setDirection(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_set_direction__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);
  {
    try {
      (arg1)->setDirection((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_set_direction(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_set_direction__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_set_direction__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Light.set_direction", 
    "    void Light.set_direction(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    void Light.set_direction(Ogre::Vector3 const &vec)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_direction

  call-seq:
    get_direction -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_direction(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Light const *)arg1)->getDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_spotlight_range

  call-seq:
    set_spotlight_range(Radian innerAngle, Radian outerAngle, Real falloff=1.0)
    set_spotlight_range(Radian innerAngle, Radian outerAngle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_spotlight_range__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);
  {
    try {
      (arg1)->setSpotlightRange((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_set_spotlight_range__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);
  {
    try {
      (arg1)->setSpotlightRange((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_set_spotlight_range(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_set_spotlight_range__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_set_spotlight_range__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Light.set_spotlight_range", 
    "    void Light.set_spotlight_range(Ogre::Radian const &innerAngle, Ogre::Radian const &outerAngle, Ogre::Real falloff)\n"
    "    void Light.set_spotlight_range(Ogre::Radian const &innerAngle, Ogre::Radian const &outerAngle)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_spotlight_inner_angle

  call-seq:
    get_spotlight_inner_angle -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_spotlight_inner_angle(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);
  {
    try {
      result = (Ogre::Radian *) &((Ogre::Light const *)arg1)->getSpotlightInnerAngle();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_spotlight_outer_angle

  call-seq:
    get_spotlight_outer_angle -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_spotlight_outer_angle(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);
  {
    try {
      result = (Ogre::Radian *) &((Ogre::Light const *)arg1)->getSpotlightOuterAngle();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_spotlight_falloff

  call-seq:
    get_spotlight_falloff -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_spotlight_falloff(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->getSpotlightFalloff();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_spotlight_inner_angle

  call-seq:
    set_spotlight_inner_angle(Radian val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_spotlight_inner_angle(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);
  {
    try {
      (arg1)->setSpotlightInnerAngle((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_spotlight_outer_angle

  call-seq:
    set_spotlight_outer_angle(Radian val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_spotlight_outer_angle(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);
  {
    try {
      (arg1)->setSpotlightOuterAngle((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_spotlight_falloff

  call-seq:
    set_spotlight_falloff(Real val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_spotlight_falloff(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);
  {
    try {
      (arg1)->setSpotlightFalloff(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_spotlight_near_clip_distance

  call-seq:
    set_spotlight_near_clip_distance(Real nearClip)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_spotlight_near_clip_distance(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);
  {
    try {
      (arg1)->setSpotlightNearClipDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_spotlight_near_clip_distance

  call-seq:
    get_spotlight_near_clip_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_spotlight_near_clip_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->getSpotlightNearClipDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_power_scale

  call-seq:
    set_power_scale(Real power)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_power_scale(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);
  {
    try {
      (arg1)->setPowerScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_power_scale

  call-seq:
    get_power_scale -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_power_scale(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->getPowerScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light._notify_attached

  call-seq:
    _notify_attached(Node parent, bool isTagPoint=false)
    _notify_attached(Node parent)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light__notify_attached(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__notify_attached__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__notify_attached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Light._notify_attached", 
    "    void Light._notify_attached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void Light._notify_attached(Ogre::Node *parent)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Light._notify_moved

  call-seq:
    _notify_moved

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light__notify_moved(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);
  {
    try {
      (arg1)->_notifyMoved();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::Light const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Light const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_derived_position

  call-seq:
    get_derived_position(bool cameraRelativeIfSet=false) -> Vector3
    get_derived_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_derived_position__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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Light const *)arg1)->getDerivedPosition(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_get_derived_position__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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Light const *)arg1)->getDerivedPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_get_derived_position(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_get_derived_position__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_get_derived_position__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Light.get_derived_position", 
    "    Ogre::Vector3 const & Light.get_derived_position(bool cameraRelativeIfSet)\n"
    "    Ogre::Vector3 const & Light.get_derived_position()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_derived_direction

  call-seq:
    get_derived_direction -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_derived_direction(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Light const *)arg1)->getDerivedDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_visible

  call-seq:
    set_visible(bool visible)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_visible(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);
  {
    try {
      (arg1)->setVisible(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_as_4dvector

  call-seq:
    get_as_4dvector(bool cameraRelativeIfSet=false) -> Vector4
    get_as_4dvector -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_as_4dvector__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);
  {
    try {
      result = ((Ogre::Light const *)arg1)->getAs4DVector(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_get_as_4dvector__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);
  {
    try {
      result = ((Ogre::Light const *)arg1)->getAs4DVector();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_get_as_4dvector(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_get_as_4dvector__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_get_as_4dvector__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Light.get_as_4dvector", 
    "    Ogre::Vector4 Light.get_as_4dvector(bool cameraRelativeIfSet)\n"
    "    Ogre::Vector4 Light.get_as_4dvector()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Light._get_near_clip_volume

  call-seq:
    _get_near_clip_volume(Camera cam) -> PlaneBoundedVolume

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light__get_near_clip_volume(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);
  {
    try {
      result = (Ogre::PlaneBoundedVolume *) &((Ogre::Light const *)arg1)->_getNearClipVolume((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PlaneBoundedVolume, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light._get_frustum_clip_volumes

  call-seq:
    _get_frustum_clip_volumes(Camera cam) -> PlaneBoundedVolumeList

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light__get_frustum_clip_volumes(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);
  {
    try {
      result = (Ogre::PlaneBoundedVolumeList *) &((Ogre::Light const *)arg1)->_getFrustumClipVolumes((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_type_flags

  call-seq:
    get_type_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_type_flags(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::Light const *)arg1)->getTypeFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.create_animable_value

  call-seq:
    create_animable_value(String valueName) -> AnimableValuePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_create_animable_value(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;
  }
  {
    try {
      result = (arg1)->createAnimableValue((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Light.set_custom_shadow_camera_setup

  call-seq:
    set_custom_shadow_camera_setup(ShadowCameraSetupPtr customShadowSetup)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_custom_shadow_camera_setup(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);
  {
    try {
      (arg1)->setCustomShadowCameraSetup((Ogre::ShadowCameraSetupPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.reset_custom_shadow_camera_setup

  call-seq:
    reset_custom_shadow_camera_setup

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_reset_custom_shadow_camera_setup(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);
  {
    try {
      (arg1)->resetCustomShadowCameraSetup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_custom_shadow_camera_setup

  call-seq:
    get_custom_shadow_camera_setup -> ShadowCameraSetupPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_custom_shadow_camera_setup(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);
  {
    try {
      result = (Ogre::ShadowCameraSetupPtr *) &((Ogre::Light const *)arg1)->getCustomShadowCameraSetup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Light.visit_renderables", 
    "    void Light.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void Light.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Light._get_index_in_frame

  call-seq:
    _get_index_in_frame -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light__get_index_in_frame(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);
  {
    try {
      result = ((Ogre::Light const *)arg1)->_getIndexInFrame();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light._notify_index_in_frame

  call-seq:
    _notify_index_in_frame(size_t i)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light__notify_index_in_frame(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);
  {
    try {
      (arg1)->_notifyIndexInFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_shadow_far_distance

  call-seq:
    set_shadow_far_distance(Real distance)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_shadow_far_distance(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);
  {
    try {
      (arg1)->setShadowFarDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.reset_shadow_far_distance

  call-seq:
    reset_shadow_far_distance

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_reset_shadow_far_distance(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);
  {
    try {
      (arg1)->resetShadowFarDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_shadow_far_distance

  call-seq:
    get_shadow_far_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_shadow_far_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->getShadowFarDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_shadow_far_distance_squared

  call-seq:
    get_shadow_far_distance_squared -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_shadow_far_distance_squared(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->getShadowFarDistanceSquared();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_shadow_near_clip_distance

  call-seq:
    set_shadow_near_clip_distance(Real nearClip)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_shadow_near_clip_distance(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);
  {
    try {
      (arg1)->setShadowNearClipDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_shadow_near_clip_distance

  call-seq:
    get_shadow_near_clip_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_shadow_near_clip_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->getShadowNearClipDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light._derive_shadow_near_clip_distance

  call-seq:
    _derive_shadow_near_clip_distance(Camera maincam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light__derive_shadow_near_clip_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->_deriveShadowNearClipDistance((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_shadow_far_clip_distance

  call-seq:
    set_shadow_far_clip_distance(Real farClip)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_shadow_far_clip_distance(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);
  {
    try {
      (arg1)->setShadowFarClipDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_shadow_far_clip_distance

  call-seq:
    get_shadow_far_clip_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_shadow_far_clip_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->getShadowFarClipDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light._derive_shadow_far_clip_distance

  call-seq:
    _derive_shadow_far_clip_distance(Camera maincam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light__derive_shadow_far_clip_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Light const *)arg1)->_deriveShadowFarClipDistance((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light._set_camera_relative

  call-seq:
    _set_camera_relative(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light__set_camera_relative(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);
  {
    try {
      (arg1)->_setCameraRelative(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.set_custom_parameter

  call-seq:
    set_custom_parameter(uint16 index, Vector4 value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_set_custom_parameter(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);
  {
    try {
      (arg1)->setCustomParameter(arg2,(Ogre::Vector4 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light.get_custom_parameter

  call-seq:
    get_custom_parameter(uint16 index) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light_get_custom_parameter(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);
  {
    try {
      result = (Ogre::Vector4 *) &((Ogre::Light const *)arg1)->getCustomParameter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Light._update_custom_gpu_parameter

  call-seq:
    _update_custom_gpu_parameter(uint16 paramIndex, AutoConstantEntry constantEntry, 
    GpuProgramParameters params)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Light__update_custom_gpu_parameter(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);
  {
    try {
      ((Ogre::Light const *)arg1)->_updateCustomGpuParameter(arg2,(Ogre::GpuProgramParameters::AutoConstantEntry const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::LightFactory < Ogre::Ogre::MovableObjectFactory

  Proxy of C++ Ogre::LightFactory class


*/
swig_class SwigClassLightFactory;

SWIGINTERN void
free_Ogre_LightFactory(Ogre::LightFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::LightFactory.FACTORY_TYPE_NAME

  call-seq:
    FACTORY_TYPE_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::LightFactory.FACTORY_TYPE_NAME=

  call-seq:
    FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::LightFactory.LightFactory_FACTORY_TYPE_NAME

  call-seq:
    LightFactory_FACTORY_TYPE_NAME -> String

Get value of attribute.

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



/*
  Document-method: Ogre::LightFactory.LightFactory_FACTORY_TYPE_NAME=

  call-seq:
    LightFactory_FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::LightFactory.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_LightFactory_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::LightFactory const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LightFactory.destroy_instance

  call-seq:
    destroy_instance(MovableObject obj)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LightFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::AutoParamDataSource

  Proxy of C++ Ogre::AutoParamDataSource class


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


/*
  Document-method: Ogre::AutoParamDataSource.new

  call-seq:
    AutoParamDataSource.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::AutoParamDataSource *)new Ogre::AutoParamDataSource();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AutoParamDataSource(Ogre::AutoParamDataSource *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::AutoParamDataSource.set_current_renderable

  call-seq:
    set_current_renderable(Renderable rend)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_current_renderable(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);
  {
    try {
      (arg1)->setCurrentRenderable((Ogre::Renderable const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_world_matrices

  call-seq:
    set_world_matrices(Matrix4 m, size_t count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_world_matrices(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);
  {
    try {
      (arg1)->setWorldMatrices((Ogre::Matrix4 const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_current_camera

  call-seq:
    set_current_camera(Camera cam, bool useCameraRelative)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_current_camera(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);
  {
    try {
      (arg1)->setCurrentCamera((Ogre::Camera const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_current_light_list

  call-seq:
    set_current_light_list(LightList ll)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_current_light_list(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);
  {
    try {
      (arg1)->setCurrentLightList((Ogre::LightList const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_texture_projector

  call-seq:
    set_texture_projector(Frustum frust, size_t index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_texture_projector(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);
  {
    try {
      (arg1)->setTextureProjector((Ogre::Frustum const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_current_render_target

  call-seq:
    set_current_render_target(RenderTarget target)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_current_render_target(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);
  {
    try {
      (arg1)->setCurrentRenderTarget((Ogre::RenderTarget const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_current_viewport

  call-seq:
    set_current_viewport(Viewport viewport)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_current_viewport(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);
  {
    try {
      (arg1)->setCurrentViewport((Ogre::Viewport const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_shadow_dir_light_extrusion_distance

  call-seq:
    set_shadow_dir_light_extrusion_distance(Real dist)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_shadow_dir_light_extrusion_distance(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);
  {
    try {
      (arg1)->setShadowDirLightExtrusionDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_main_cam_bounds_info

  call-seq:
    set_main_cam_bounds_info(VisibleObjectsBoundsInfo info)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_main_cam_bounds_info(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);
  {
    try {
      (arg1)->setMainCamBoundsInfo(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_current_scene_manager

  call-seq:
    set_current_scene_manager(SceneManager sm)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_current_scene_manager(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);
  {
    try {
      (arg1)->setCurrentSceneManager((Ogre::SceneManager const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_current_pass

  call-seq:
    set_current_pass(Pass pass)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_current_pass(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);
  {
    try {
      (arg1)->setCurrentPass((Ogre::Pass const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_world_matrix

  call-seq:
    get_world_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_world_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getWorldMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_world_matrix_array

  call-seq:
    get_world_matrix_array -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_world_matrix_array(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);
  {
    try {
      result = (Ogre::Matrix4 *)((Ogre::AutoParamDataSource const *)arg1)->getWorldMatrixArray();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_world_matrix_count

  call-seq:
    get_world_matrix_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_world_matrix_count(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getWorldMatrixCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_view_matrix

  call-seq:
    get_view_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_view_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getViewMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_view_projection_matrix

  call-seq:
    get_view_projection_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_view_projection_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getViewProjectionMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_projection_matrix

  call-seq:
    get_projection_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_projection_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getProjectionMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_world_view_proj_matrix

  call-seq:
    get_world_view_proj_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_world_view_proj_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getWorldViewProjMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_world_view_matrix

  call-seq:
    get_world_view_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_world_view_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getWorldViewMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_world_matrix

  call-seq:
    get_inverse_world_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_world_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getInverseWorldMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_world_view_matrix

  call-seq:
    get_inverse_world_view_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_world_view_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getInverseWorldViewMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_view_matrix

  call-seq:
    get_inverse_view_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_view_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getInverseViewMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_transpose_world_matrix

  call-seq:
    get_inverse_transpose_world_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_transpose_world_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getInverseTransposeWorldMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_transpose_world_view_matrix

  call-seq:
    get_inverse_transpose_world_view_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_transpose_world_view_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getInverseTransposeWorldViewMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_camera_position

  call-seq:
    get_camera_position -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_camera_position(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);
  {
    try {
      result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getCameraPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_camera_position_object_space

  call-seq:
    get_camera_position_object_space -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_camera_position_object_space(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);
  {
    try {
      result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getCameraPositionObjectSpace();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_lod_camera_position

  call-seq:
    get_lod_camera_position -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_lod_camera_position(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);
  {
    try {
      result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getLodCameraPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_lod_camera_position_object_space

  call-seq:
    get_lod_camera_position_object_space -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_lod_camera_position_object_space(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);
  {
    try {
      result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getLodCameraPositionObjectSpace();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.has_light_list

  call-seq:
    has_light_list -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_has_light_list(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);
  {
    try {
      result = (bool)((Ogre::AutoParamDataSource const *)arg1)->hasLightList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_light_number

  call-seq:
    get_light_number(size_t index) -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_light_number(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);
  {
    try {
      result = (float)((Ogre::AutoParamDataSource const *)arg1)->getLightNumber(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_light_count

  call-seq:
    get_light_count -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_light_count(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);
  {
    try {
      result = (float)((Ogre::AutoParamDataSource const *)arg1)->getLightCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_light_casts_shadows

  call-seq:
    get_light_casts_shadows(size_t index) -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_light_casts_shadows(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);
  {
    try {
      result = (float)((Ogre::AutoParamDataSource const *)arg1)->getLightCastsShadows(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_light_diffuse_colour

  call-seq:
    get_light_diffuse_colour(size_t index) -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_light_diffuse_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getLightDiffuseColour(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_light_specular_colour

  call-seq:
    get_light_specular_colour(size_t index) -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_light_specular_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getLightSpecularColour(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_light_diffuse_colour_with_power

  call-seq:
    get_light_diffuse_colour_with_power(size_t index) -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_light_diffuse_colour_with_power(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getLightDiffuseColourWithPower(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_light_specular_colour_with_power

  call-seq:
    get_light_specular_colour_with_power(size_t index) -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_light_specular_colour_with_power(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getLightSpecularColourWithPower(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_light_position

  call-seq:
    get_light_position(size_t index) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_light_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::AutoParamDataSource const *)arg1)->getLightPosition(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_light_as_4dvector

  call-seq:
    get_light_as_4dvector(size_t index) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_light_as_4dvector(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getLightAs4DVector(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_light_direction

  call-seq:
    get_light_direction(size_t index) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_light_direction(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::AutoParamDataSource const *)arg1)->getLightDirection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_light_power_scale

  call-seq:
    get_light_power_scale(size_t index) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_light_power_scale(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getLightPowerScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_light_attenuation

  call-seq:
    get_light_attenuation(size_t index) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_light_attenuation(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getLightAttenuation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_spotlight_params

  call-seq:
    get_spotlight_params(size_t index) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_spotlight_params(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getSpotlightParams(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_ambient_light_colour

  call-seq:
    set_ambient_light_colour(ColourValue ambient)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_ambient_light_colour(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);
  {
    try {
      (arg1)->setAmbientLightColour((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_ambient_light_colour

  call-seq:
    get_ambient_light_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_ambient_light_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getAmbientLightColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_surface_ambient_colour

  call-seq:
    get_surface_ambient_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_surface_ambient_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getSurfaceAmbientColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_surface_diffuse_colour

  call-seq:
    get_surface_diffuse_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_surface_diffuse_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getSurfaceDiffuseColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_surface_specular_colour

  call-seq:
    get_surface_specular_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_surface_specular_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getSurfaceSpecularColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_surface_emissive_colour

  call-seq:
    get_surface_emissive_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_surface_emissive_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getSurfaceEmissiveColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_surface_shininess

  call-seq:
    get_surface_shininess -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_surface_shininess(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getSurfaceShininess();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_derived_ambient_light_colour

  call-seq:
    get_derived_ambient_light_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_derived_ambient_light_colour(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getDerivedAmbientLightColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_derived_scene_colour

  call-seq:
    get_derived_scene_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_derived_scene_colour(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getDerivedSceneColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_fog

  call-seq:
    set_fog(FogMode mode, ColourValue colour, Real expDensity, 
    Real linearStart, Real linearEnd)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_fog(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);
  {
    try {
      (arg1)->setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_fog_colour

  call-seq:
    get_fog_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_fog_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getFogColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_fog_params

  call-seq:
    get_fog_params -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_fog_params(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);
  {
    try {
      result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getFogParams();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_texture_view_proj_matrix

  call-seq:
    get_texture_view_proj_matrix(size_t index) -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_texture_view_proj_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getTextureViewProjMatrix(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_texture_world_view_proj_matrix

  call-seq:
    get_texture_world_view_proj_matrix(size_t index) -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_texture_world_view_proj_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getTextureWorldViewProjMatrix(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_spotlight_view_proj_matrix

  call-seq:
    get_spotlight_view_proj_matrix(size_t index) -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_spotlight_view_proj_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getSpotlightViewProjMatrix(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_spotlight_world_view_proj_matrix

  call-seq:
    get_spotlight_world_view_proj_matrix(size_t index) -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_spotlight_world_view_proj_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getSpotlightWorldViewProjMatrix(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_texture_transform_matrix

  call-seq:
    get_texture_transform_matrix(size_t index) -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_texture_transform_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getTextureTransformMatrix(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_current_render_target

  call-seq:
    get_current_render_target -> RenderTarget

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_current_render_target(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);
  {
    try {
      result = (Ogre::RenderTarget *)((Ogre::AutoParamDataSource const *)arg1)->getCurrentRenderTarget();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_current_renderable

  call-seq:
    get_current_renderable -> Renderable

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_current_renderable(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);
  {
    try {
      result = (Ogre::Renderable *)((Ogre::AutoParamDataSource const *)arg1)->getCurrentRenderable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_current_pass

  call-seq:
    get_current_pass -> Pass

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_current_pass(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);
  {
    try {
      result = (Ogre::Pass *)((Ogre::AutoParamDataSource const *)arg1)->getCurrentPass();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_texture_size

  call-seq:
    get_texture_size(size_t index) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_texture_size(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getTextureSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_texture_size

  call-seq:
    get_inverse_texture_size(size_t index) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_texture_size(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseTextureSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_packed_texture_size

  call-seq:
    get_packed_texture_size(size_t index) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_packed_texture_size(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getPackedTextureSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_shadow_extrusion_distance

  call-seq:
    get_shadow_extrusion_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_shadow_extrusion_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getShadowExtrusionDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_scene_depth_range

  call-seq:
    get_scene_depth_range -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_scene_depth_range(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);
  {
    try {
      result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getSceneDepthRange();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_shadow_scene_depth_range

  call-seq:
    get_shadow_scene_depth_range(size_t index) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_shadow_scene_depth_range(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);
  {
    try {
      result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getShadowSceneDepthRange(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_shadow_colour

  call-seq:
    get_shadow_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_shadow_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getShadowColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_view_proj_matrix

  call-seq:
    get_inverse_view_proj_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_view_proj_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseViewProjMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_transpose_view_proj_matrix

  call-seq:
    get_inverse_transpose_view_proj_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_transpose_view_proj_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseTransposeViewProjMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_transpose_view_proj_matrix

  call-seq:
    get_transpose_view_proj_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_transpose_view_proj_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getTransposeViewProjMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_transpose_view_matrix

  call-seq:
    get_transpose_view_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_transpose_view_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getTransposeViewMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_transpose_view_matrix

  call-seq:
    get_inverse_transpose_view_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_transpose_view_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseTransposeViewMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_transpose_projection_matrix

  call-seq:
    get_transpose_projection_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_transpose_projection_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getTransposeProjectionMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_projection_matrix

  call-seq:
    get_inverse_projection_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_projection_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseProjectionMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_transpose_projection_matrix

  call-seq:
    get_inverse_transpose_projection_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_transpose_projection_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseTransposeProjectionMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_transpose_world_view_proj_matrix

  call-seq:
    get_transpose_world_view_proj_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_transpose_world_view_proj_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getTransposeWorldViewProjMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_world_view_proj_matrix

  call-seq:
    get_inverse_world_view_proj_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_world_view_proj_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseWorldViewProjMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_transpose_world_view_proj_matrix

  call-seq:
    get_inverse_transpose_world_view_proj_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_transpose_world_view_proj_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseTransposeWorldViewProjMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_transpose_world_view_matrix

  call-seq:
    get_transpose_world_view_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_transpose_world_view_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getTransposeWorldViewMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_transpose_world_matrix

  call-seq:
    get_transpose_world_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_transpose_world_matrix(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getTransposeWorldMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_time

  call-seq:
    get_time -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_time(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTime();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_time_0_x

  call-seq:
    get_time_0_x(Real x) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_time_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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTime_0_X(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_cos_time_0_x

  call-seq:
    get_cos_time_0_x(Real x) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_cos_time_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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getCosTime_0_X(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_sin_time_0_x

  call-seq:
    get_sin_time_0_x(Real x) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_sin_time_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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getSinTime_0_X(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_tan_time_0_x

  call-seq:
    get_tan_time_0_x(Real x) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_tan_time_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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTanTime_0_X(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_time_0_x_packed

  call-seq:
    get_time_0_x_packed(Real x) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_time_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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getTime_0_X_packed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_time_0_1

  call-seq:
    get_time_0_1(Real x) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_time_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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTime_0_1(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_cos_time_0_1

  call-seq:
    get_cos_time_0_1(Real x) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_cos_time_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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getCosTime_0_1(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_sin_time_0_1

  call-seq:
    get_sin_time_0_1(Real x) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_sin_time_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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getSinTime_0_1(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_tan_time_0_1

  call-seq:
    get_tan_time_0_1(Real x) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_tan_time_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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTanTime_0_1(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_time_0_1_packed

  call-seq:
    get_time_0_1_packed(Real x) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_time_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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getTime_0_1_packed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_time_0_2pi

  call-seq:
    get_time_0_2pi(Real x) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_time_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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTime_0_2Pi(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_cos_time_0_2pi

  call-seq:
    get_cos_time_0_2pi(Real x) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_cos_time_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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getCosTime_0_2Pi(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_sin_time_0_2pi

  call-seq:
    get_sin_time_0_2pi(Real x) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_sin_time_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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getSinTime_0_2Pi(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_tan_time_0_2pi

  call-seq:
    get_tan_time_0_2pi(Real x) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_tan_time_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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTanTime_0_2Pi(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_time_0_2pi_packed

  call-seq:
    get_time_0_2pi_packed(Real x) -> Vector4

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_time_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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getTime_0_2Pi_packed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_frame_time

  call-seq:
    get_frame_time -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_frame_time(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getFrameTime();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_fps

  call-seq:
    get_fps -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_fps(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getFPS();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_viewport_width

  call-seq:
    get_viewport_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_viewport_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getViewportWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_viewport_height

  call-seq:
    get_viewport_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_viewport_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getViewportHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_viewport_width

  call-seq:
    get_inverse_viewport_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_viewport_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getInverseViewportWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_inverse_viewport_height

  call-seq:
    get_inverse_viewport_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_inverse_viewport_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getInverseViewportHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_view_direction

  call-seq:
    get_view_direction -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_view_direction(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getViewDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_view_side_vector

  call-seq:
    get_view_side_vector -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_view_side_vector(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getViewSideVector();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_view_up_vector

  call-seq:
    get_view_up_vector -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_view_up_vector(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);
  {
    try {
      result = ((Ogre::AutoParamDataSource const *)arg1)->getViewUpVector();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_fov

  call-seq:
    get_fov -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_fov(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getFOV();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_near_clip_distance

  call-seq:
    get_near_clip_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_near_clip_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getNearClipDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_far_clip_distance

  call-seq:
    get_far_clip_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_far_clip_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getFarClipDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.get_pass_number

  call-seq:
    get_pass_number -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_get_pass_number(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);
  {
    try {
      result = (int)((Ogre::AutoParamDataSource const *)arg1)->getPassNumber();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.set_pass_number

  call-seq:
    set_pass_number(int passNumber)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_set_pass_number(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);
  {
    try {
      (arg1)->setPassNumber(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.inc_pass_number

  call-seq:
    inc_pass_number

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_inc_pass_number(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);
  {
    try {
      (arg1)->incPassNumber();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AutoParamDataSource.update_light_custom_gpu_parameter

  call-seq:
    update_light_custom_gpu_parameter(AutoConstantEntry constantEntry, GpuProgramParameters params)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AutoParamDataSource_update_light_custom_gpu_parameter(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);
  {
    try {
      ((Ogre::AutoParamDataSource const *)arg1)->updateLightCustomGpuParameter((Ogre::GpuProgramParameters::AutoConstantEntry const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Billboard

  Proxy of C++ Ogre::Billboard class


*/
swig_class SwigClassBillboard;


/*
  Document-method: Ogre::Billboard.mPosition

  call-seq:
    mPosition -> Vector3

Get value of attribute.

*/

/*
  Document-method: Ogre::Billboard.mPosition=

  call-seq:
    mPosition=(x) -> Vector3

Set new value for attribute.

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



/*
  Document-method: Ogre::Billboard.mDirection

  call-seq:
    mDirection -> Vector3

Get value of attribute.

*/

/*
  Document-method: Ogre::Billboard.mDirection=

  call-seq:
    mDirection=(x) -> Vector3

Set new value for attribute.

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



/*
  Document-method: Ogre::Billboard.mParentSet

  call-seq:
    mParentSet -> BillboardSet

Get value of attribute.

*/

/*
  Document-method: Ogre::Billboard.mParentSet=

  call-seq:
    mParentSet=(x) -> BillboardSet

Set new value for attribute.

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



/*
  Document-method: Ogre::Billboard.mColour

  call-seq:
    mColour -> ColourValue

Get value of attribute.

*/

/*
  Document-method: Ogre::Billboard.mColour=

  call-seq:
    mColour=(x) -> ColourValue

Set new value for attribute.

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



/*
  Document-method: Ogre::Billboard.mRotation

  call-seq:
    mRotation -> Radian

Get value of attribute.

*/

/*
  Document-method: Ogre::Billboard.mRotation=

  call-seq:
    mRotation=(x) -> Radian

Set new value for attribute.

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



/*
  Document-method: Ogre::Billboard.new

  call-seq:
    Billboard.new
    Billboard.new(Vector3 position, BillboardSet owner, ColourValue colour=White)
    Billboard.new(Vector3 position, BillboardSet owner)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Billboard *)new Ogre::Billboard();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_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);
  {
    try {
      result = (Ogre::Billboard *)new Ogre::Billboard((Ogre::Vector3 const &)*arg1,arg2,(Ogre::ColourValue const &)*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::Billboard *)new Ogre::Billboard((Ogre::Vector3 const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::Billboard.get_rotation

  call-seq:
    get_rotation -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_get_rotation(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);
  {
    try {
      result = (Ogre::Radian *) &((Ogre::Billboard const *)arg1)->getRotation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.set_rotation

  call-seq:
    set_rotation(Radian rotation)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_set_rotation(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);
  {
    try {
      (arg1)->setRotation((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.set_position

  call-seq:
    set_position(Vector3 position)
    set_position(Real x, Real y, Real z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_set_position__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);
  {
    try {
      (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_set_position__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);
  {
    try {
      (arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Billboard_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_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_set_position__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_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Billboard.set_position", 
    "    void Billboard.set_position(Ogre::Vector3 const &position)\n"
    "    void Billboard.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.get_position

  call-seq:
    get_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_get_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Billboard const *)arg1)->getPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.set_dimensions

  call-seq:
    set_dimensions(Real width, Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_set_dimensions(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);
  {
    try {
      (arg1)->setDimensions(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.reset_dimensions

  call-seq:
    reset_dimensions

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_reset_dimensions(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);
  {
    try {
      (arg1)->resetDimensions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.set_colour

  call-seq:
    set_colour(ColourValue colour)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_set_colour(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);
  {
    try {
      (arg1)->setColour((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.get_colour

  call-seq:
    get_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_get_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::Billboard const *)arg1)->getColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.has_own_dimensions

  call-seq:
    has_own_dimensions -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_has_own_dimensions(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);
  {
    try {
      result = (bool)((Ogre::Billboard const *)arg1)->hasOwnDimensions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.get_own_width

  call-seq:
    get_own_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_get_own_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Billboard const *)arg1)->getOwnWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.get_own_height

  call-seq:
    get_own_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_get_own_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Billboard const *)arg1)->getOwnHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard._notify_owner

  call-seq:
    _notify_owner(BillboardSet owner)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard__notify_owner(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);
  {
    try {
      (arg1)->_notifyOwner(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.is_use_texcoord_rect

  call-seq:
    is_use_texcoord_rect -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_is_use_texcoord_rect(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);
  {
    try {
      result = (bool)((Ogre::Billboard const *)arg1)->isUseTexcoordRect();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.set_texcoord_index

  call-seq:
    set_texcoord_index(uint16 texcoordIndex)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_set_texcoord_index(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);
  {
    try {
      (arg1)->setTexcoordIndex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.get_texcoord_index

  call-seq:
    get_texcoord_index -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_get_texcoord_index(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::Billboard const *)arg1)->getTexcoordIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.set_texcoord_rect

  call-seq:
    set_texcoord_rect(FloatRect texcoordRect)
    set_texcoord_rect(Real u0, Real v0, Real u1, Real v1)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_set_texcoord_rect__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);
  {
    try {
      (arg1)->setTexcoordRect((Ogre::FloatRect const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_set_texcoord_rect__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);
  {
    try {
      (arg1)->setTexcoordRect(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Billboard_set_texcoord_rect(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_set_texcoord_rect__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_set_texcoord_rect__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Billboard.set_texcoord_rect", 
    "    void Billboard.set_texcoord_rect(Ogre::FloatRect const &texcoordRect)\n"
    "    void Billboard.set_texcoord_rect(Ogre::Real u0, Ogre::Real v0, Ogre::Real u1, Ogre::Real v1)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Billboard.get_texcoord_rect

  call-seq:
    get_texcoord_rect -> FloatRect

An instance method.

*/
SWIGINTERN VALUE
_wrap_Billboard_get_texcoord_rect(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);
  {
    try {
      result = (Ogre::FloatRect *) &((Ogre::Billboard const *)arg1)->getTexcoordRect();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TRectT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::BillboardChain < Ogre::Ogre::MovableObject, Ogre::Ogre::Renderable

  Proxy of C++ Ogre::BillboardChain class


*/
swig_class SwigClassBillboardChain;


/*
  Document-method: Ogre::BillboardChain.new

  call-seq:
    BillboardChain.new(String name, size_t maxElements=20, size_t numberOfChains=1, 
    bool useTextureCoords=true, bool useColours=true, 
    bool dynamic=true)
    BillboardChain.new(String name, size_t maxElements=20, size_t numberOfChains=1, 
    bool useTextureCoords=true, bool useColours=true)
    BillboardChain.new(String name, size_t maxElements=20, size_t numberOfChains=1, 
    bool useTextureCoords=true)
    BillboardChain.new(String name, size_t maxElements=20, size_t numberOfChains=1)
    BillboardChain.new(String name, size_t maxElements=20)
    BillboardChain.new(String name)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::BillboardChain *)new Ogre::BillboardChain((Ogre::String const &)*arg1,arg2,arg3,arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::BillboardChain *)new Ogre::BillboardChain((Ogre::String const &)*arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::BillboardChain *)new Ogre::BillboardChain((Ogre::String const &)*arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::BillboardChain *)new Ogre::BillboardChain((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::BillboardChain *)new Ogre::BillboardChain((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::BillboardChain *)new Ogre::BillboardChain((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::BillboardChain.set_max_chain_elements

  call-seq:
    set_max_chain_elements(size_t maxElements)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_set_max_chain_elements(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);
  {
    try {
      (arg1)->setMaxChainElements(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_max_chain_elements

  call-seq:
    get_max_chain_elements -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_max_chain_elements(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);
  {
    try {
      result = ((Ogre::BillboardChain const *)arg1)->getMaxChainElements();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.set_number_of_chains

  call-seq:
    set_number_of_chains(size_t numChains)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_set_number_of_chains(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);
  {
    try {
      (arg1)->setNumberOfChains(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_number_of_chains

  call-seq:
    get_number_of_chains -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_number_of_chains(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);
  {
    try {
      result = ((Ogre::BillboardChain const *)arg1)->getNumberOfChains();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.set_use_texture_coords

  call-seq:
    set_use_texture_coords(bool use)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_set_use_texture_coords(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);
  {
    try {
      (arg1)->setUseTextureCoords(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_use_texture_coords

  call-seq:
    get_use_texture_coords -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_use_texture_coords(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);
  {
    try {
      result = (bool)((Ogre::BillboardChain const *)arg1)->getUseTextureCoords();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TexCoordDirection.TCD_U

  call-seq:
    TCD_U -> int

A class method.

*/

/*
  Document-method: Ogre::TexCoordDirection.TCD_V

  call-seq:
    TCD_V -> int

A class method.

*/

/*
  Document-method: Ogre::BillboardChain.set_texture_coord_direction

  call-seq:
    set_texture_coord_direction(TexCoordDirection dir)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_set_texture_coord_direction(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);
  {
    try {
      (arg1)->setTextureCoordDirection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_texture_coord_direction

  call-seq:
    get_texture_coord_direction -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_texture_coord_direction(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);
  {
    try {
      result = (Ogre::BillboardChain::TexCoordDirection)(arg1)->getTextureCoordDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.set_other_texture_coord_range

  call-seq:
    set_other_texture_coord_range(Real start, Real end)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_set_other_texture_coord_range(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);
  {
    try {
      (arg1)->setOtherTextureCoordRange(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_other_texture_coord_range

  call-seq:
    get_other_texture_coord_range -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_other_texture_coord_range(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);
  {
    try {
      result = (Ogre::Real *)((Ogre::BillboardChain const *)arg1)->getOtherTextureCoordRange();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.set_use_vertex_colours

  call-seq:
    set_use_vertex_colours(bool use)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_set_use_vertex_colours(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);
  {
    try {
      (arg1)->setUseVertexColours(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_use_vertex_colours

  call-seq:
    get_use_vertex_colours -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_use_vertex_colours(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);
  {
    try {
      result = (bool)((Ogre::BillboardChain const *)arg1)->getUseVertexColours();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.set_dynamic

  call-seq:
    set_dynamic(bool dyn)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_set_dynamic(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);
  {
    try {
      (arg1)->setDynamic(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_dynamic

  call-seq:
    get_dynamic -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_dynamic(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);
  {
    try {
      result = (bool)((Ogre::BillboardChain const *)arg1)->getDynamic();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.add_chain_element

  call-seq:
    add_chain_element(size_t chainIndex, Element billboardChainElement)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_add_chain_element(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);
  {
    try {
      (arg1)->addChainElement(arg2,(Ogre::BillboardChain::Element const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.remove_chain_element

  call-seq:
    remove_chain_element(size_t chainIndex)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_remove_chain_element(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);
  {
    try {
      (arg1)->removeChainElement(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.update_chain_element

  call-seq:
    update_chain_element(size_t chainIndex, size_t elementIndex, Element billboardChainElement)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_update_chain_element(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);
  {
    try {
      (arg1)->updateChainElement(arg2,arg3,(Ogre::BillboardChain::Element const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_chain_element

  call-seq:
    get_chain_element(size_t chainIndex, size_t elementIndex) -> Element

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_chain_element(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);
  {
    try {
      result = (Ogre::BillboardChain::Element *) &((Ogre::BillboardChain const *)arg1)->getChainElement(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardChain__Element, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_num_chain_elements

  call-seq:
    get_num_chain_elements(size_t chainIndex) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_num_chain_elements(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);
  {
    try {
      result = ((Ogre::BillboardChain const *)arg1)->getNumChainElements(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.clear_chain

  call-seq:
    clear_chain(size_t chainIndex)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_clear_chain(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);
  {
    try {
      (arg1)->clearChain(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.clear_all_chains

  call-seq:
    clear_all_chains

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_clear_all_chains(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);
  {
    try {
      (arg1)->clearAllChains();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.set_face_camera

  call-seq:
    set_face_camera(bool faceCamera, Vector3 normalVector=UNIT_X)
    set_face_camera(bool faceCamera)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_set_face_camera__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);
  {
    try {
      (arg1)->setFaceCamera(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_set_face_camera__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);
  {
    try {
      (arg1)->setFaceCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardChain_set_face_camera(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_set_face_camera__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_set_face_camera__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardChain.set_face_camera", 
    "    void BillboardChain.set_face_camera(bool faceCamera, Ogre::Vector3 const &normalVector)\n"
    "    void BillboardChain.set_face_camera(bool faceCamera)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_material_name

  call-seq:
    get_material_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_material_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::BillboardChain const *)arg1)->getMaterialName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.set_material_name

  call-seq:
    set_material_name(String name, String groupName=AUTODETECT_RESOURCE_GROUP_NAME)
    set_material_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardChain_set_material_name(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_set_material_name__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_set_material_name__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardChain.set_material_name", 
    "    void BillboardChain.set_material_name(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    void BillboardChain.set_material_name(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera cam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::BillboardChain const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::BillboardChain const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::BillboardChain const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::BillboardChain const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::BillboardChain const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue ?)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_render_operation

  call-seq:
    get_render_operation(RenderOperation ?)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_render_operation(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);
  {
    try {
      (arg1)->getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.pre_render

  call-seq:
    pre_render(SceneManager sm, RenderSystem rsys) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_pre_render(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 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__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","preRender", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(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);
  {
    try {
      result = (bool)(arg1)->preRender(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 ?)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_world_transforms(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);
  {
    try {
      ((Ogre::BillboardChain const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.get_lights

  call-seq:
    get_lights -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_get_lights(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::BillboardChain const *)arg1)->getLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChain.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChain_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardChain_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardChain.visit_renderables", 
    "    void BillboardChain.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void BillboardChain.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::BillboardChainFactory < Ogre::Ogre::MovableObjectFactory

  Proxy of C++ Ogre::BillboardChainFactory class


*/
swig_class SwigClassBillboardChainFactory;

SWIGINTERN void
free_Ogre_BillboardChainFactory(Ogre::BillboardChainFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::BillboardChainFactory.FACTORY_TYPE_NAME

  call-seq:
    FACTORY_TYPE_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::BillboardChainFactory.FACTORY_TYPE_NAME=

  call-seq:
    FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::BillboardChainFactory.BillboardChainFactory_FACTORY_TYPE_NAME

  call-seq:
    BillboardChainFactory_FACTORY_TYPE_NAME -> String

Get value of attribute.

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



/*
  Document-method: Ogre::BillboardChainFactory.BillboardChainFactory_FACTORY_TYPE_NAME=

  call-seq:
    BillboardChainFactory_FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::BillboardChainFactory.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChainFactory_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::BillboardChainFactory const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardChainFactory.destroy_instance

  call-seq:
    destroy_instance(MovableObject obj)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardChainFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ParticleSystemRenderer < Ogre::Ogre::StringInterface

  Proxy of C++ Ogre::ParticleSystemRenderer class


*/
swig_class SwigClassParticleSystemRenderer;

SWIGINTERN void
free_Ogre_ParticleSystemRenderer(Ogre::ParticleSystemRenderer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ParticleSystemRenderer.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ParticleSystemRenderer const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue, Ogre::list<(p.Ogre::Particle,Ogre::STLAllocator<(p.Ogre::Particle,Ogre::GeneralAllocPolicy)>)>::type currentParticles, 
    bool cullIndividually)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2,*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._set_material

  call-seq:
    _set_material(MaterialPtr mat)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__set_material(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);
  {
    try {
      (arg1)->_setMaterial(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._notify_current_camera

  call-seq:
    _notify_current_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notify_current_camera(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);
  {
    try {
      (arg1)->_notifyCurrentCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._notify_attached

  call-seq:
    _notify_attached(Node parent, bool isTagPoint=false)
    _notify_attached(Node parent)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystemRenderer__notify_attached(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__notify_attached__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__notify_attached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystemRenderer._notify_attached", 
    "    void ParticleSystemRenderer._notify_attached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void ParticleSystemRenderer._notify_attached(Ogre::Node *parent)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._notify_particle_rotated

  call-seq:
    _notify_particle_rotated

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notify_particle_rotated(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);
  {
    try {
      (arg1)->_notifyParticleRotated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._notify_particle_resized

  call-seq:
    _notify_particle_resized

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notify_particle_resized(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);
  {
    try {
      (arg1)->_notifyParticleResized();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._notify_particle_quota

  call-seq:
    _notify_particle_quota(size_t quota)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notify_particle_quota(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);
  {
    try {
      (arg1)->_notifyParticleQuota(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._notify_default_dimensions

  call-seq:
    _notify_default_dimensions(Real width, Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notify_default_dimensions(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);
  {
    try {
      (arg1)->_notifyDefaultDimensions(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._notify_particle_emitted

  call-seq:
    _notify_particle_emitted(Particle particle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notify_particle_emitted(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);
  {
    try {
      (arg1)->_notifyParticleEmitted(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._notify_particle_expired

  call-seq:
    _notify_particle_expired(Particle particle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notify_particle_expired(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);
  {
    try {
      (arg1)->_notifyParticleExpired(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._notify_particle_moved

  call-seq:
    _notify_particle_moved(Ogre::list<(p.Ogre::Particle,Ogre::STLAllocator<(p.Ogre::Particle,Ogre::GeneralAllocPolicy)>)>::type currentParticles)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notify_particle_moved(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);
  {
    try {
      (arg1)->_notifyParticleMoved(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._notify_particle_cleared

  call-seq:
    _notify_particle_cleared(Ogre::list<(p.Ogre::Particle,Ogre::STLAllocator<(p.Ogre::Particle,Ogre::GeneralAllocPolicy)>)>::type currentParticles)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notify_particle_cleared(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);
  {
    try {
      (arg1)->_notifyParticleCleared(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._create_visual_data

  call-seq:
    _create_visual_data -> ParticleVisualData

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__create_visual_data(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);
  {
    try {
      result = (Ogre::ParticleVisualData *)(arg1)->_createVisualData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleVisualData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._destroy_visual_data

  call-seq:
    _destroy_visual_data(ParticleVisualData vis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__destroy_visual_data(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);
  {
    try {
      (arg1)->_destroyVisualData(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer.set_render_queue_group

  call-seq:
    set_render_queue_group(uint8 queueID)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer_set_render_queue_group(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);
  {
    try {
      (arg1)->setRenderQueueGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer.set_render_queue_group_and_priority

  call-seq:
    set_render_queue_group_and_priority(uint8 queueID, ushort priority)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer_set_render_queue_group_and_priority(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 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__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","setRenderQueueGroupAndPriority", 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","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);
  {
    try {
      (arg1)->setRenderQueueGroupAndPriority(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer.set_keep_particles_in_local_space

  call-seq:
    set_keep_particles_in_local_space(bool keepLocal)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer_set_keep_particles_in_local_space(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);
  {
    try {
      (arg1)->setKeepParticlesInLocalSpace(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer._get_sort_mode

  call-seq:
    _get_sort_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__get_sort_mode(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);
  {
    try {
      result = (Ogre::SortMode)((Ogre::ParticleSystemRenderer const *)arg1)->_getSortMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemRenderer.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemRenderer_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystemRenderer_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystemRenderer.visit_renderables", 
    "    void ParticleSystemRenderer.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void ParticleSystemRenderer.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::ParticleSystemRendererFactory

  Proxy of C++ Ogre::ParticleSystemRendererFactory class


*/
swig_class SwigClassParticleSystemRendererFactory;

SWIGINTERN void
free_Ogre_ParticleSystemRendererFactory(Ogre::ParticleSystemRendererFactory *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::BillboardSet < Ogre::Ogre::MovableObject, Ogre::Ogre::Renderable

  Proxy of C++ Ogre::BillboardSet class


*/
swig_class SwigClassBillboardSet;


/*
  Document-method: Ogre::BillboardSet.new

  call-seq:
    BillboardSet.new(String name, unsigned int poolSize=20, bool externalDataSource=false)
    BillboardSet.new(String name, unsigned int poolSize=20)
    BillboardSet.new(String name)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::BillboardSet *)new Ogre::BillboardSet((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::BillboardSet *)new Ogre::BillboardSet((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::BillboardSet *)new Ogre::BillboardSet((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::BillboardSet.create_billboard

  call-seq:
    create_billboard(Vector3 position, ColourValue colour=White) -> Billboard
    create_billboard(Vector3 position) -> Billboard
    create_billboard(Real x, Real y, Real z, ColourValue colour=White) -> Billboard
    create_billboard(Real x, Real y, Real z) -> Billboard

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_create_billboard__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);
  {
    try {
      result = (Ogre::Billboard *)(arg1)->createBillboard((Ogre::Vector3 const &)*arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Billboard, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_create_billboard__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);
  {
    try {
      result = (Ogre::Billboard *)(arg1)->createBillboard((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Billboard, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_create_billboard__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);
  {
    try {
      result = (Ogre::Billboard *)(arg1)->createBillboard(arg2,arg3,arg4,(Ogre::ColourValue const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Billboard, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_create_billboard__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);
  {
    try {
      result = (Ogre::Billboard *)(arg1)->createBillboard(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Billboard, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardSet_create_billboard(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_create_billboard__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_create_billboard__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_create_billboard__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_create_billboard__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "BillboardSet.create_billboard", 
    "    Ogre::Billboard * BillboardSet.create_billboard(Ogre::Vector3 const &position, Ogre::ColourValue const &colour)\n"
    "    Ogre::Billboard * BillboardSet.create_billboard(Ogre::Vector3 const &position)\n"
    "    Ogre::Billboard * BillboardSet.create_billboard(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::ColourValue const &colour)\n"
    "    Ogre::Billboard * BillboardSet.create_billboard(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_num_billboards

  call-seq:
    get_num_billboards -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_num_billboards(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);
  {
    try {
      result = (int)((Ogre::BillboardSet const *)arg1)->getNumBillboards();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_autoextend

  call-seq:
    set_autoextend(bool autoextend)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_autoextend(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);
  {
    try {
      (arg1)->setAutoextend(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_autoextend

  call-seq:
    get_autoextend -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_autoextend(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);
  {
    try {
      result = (bool)((Ogre::BillboardSet const *)arg1)->getAutoextend();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_sorting_enabled

  call-seq:
    set_sorting_enabled(bool sortenable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_sorting_enabled(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);
  {
    try {
      (arg1)->setSortingEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_sorting_enabled

  call-seq:
    get_sorting_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_sorting_enabled(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);
  {
    try {
      result = (bool)((Ogre::BillboardSet const *)arg1)->getSortingEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_pool_size

  call-seq:
    set_pool_size(size_t size)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_pool_size(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);
  {
    try {
      (arg1)->setPoolSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_pool_size

  call-seq:
    get_pool_size -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_pool_size(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);
  {
    try {
      result = (unsigned int)((Ogre::BillboardSet const *)arg1)->getPoolSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_billboard

  call-seq:
    get_billboard(unsigned int index) -> Billboard

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_billboard(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);
  {
    try {
      result = (Ogre::Billboard *)((Ogre::BillboardSet const *)arg1)->getBillboard(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Billboard, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.remove_billboard

  call-seq:
    remove_billboard(unsigned int index)
    remove_billboard(Billboard pBill)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_remove_billboard__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);
  {
    try {
      (arg1)->removeBillboard(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_remove_billboard__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);
  {
    try {
      (arg1)->removeBillboard(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardSet_remove_billboard(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_remove_billboard__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_remove_billboard__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "BillboardSet.remove_billboard", 
    "    void BillboardSet.remove_billboard(unsigned int index)\n"
    "    void BillboardSet.remove_billboard(Ogre::Billboard *pBill)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_billboard_origin

  call-seq:
    set_billboard_origin(BillboardOrigin origin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_billboard_origin(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);
  {
    try {
      (arg1)->setBillboardOrigin(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_billboard_origin

  call-seq:
    get_billboard_origin -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_billboard_origin(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);
  {
    try {
      result = (Ogre::BillboardOrigin)((Ogre::BillboardSet const *)arg1)->getBillboardOrigin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_billboard_rotation_type

  call-seq:
    set_billboard_rotation_type(BillboardRotationType rotationType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_billboard_rotation_type(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);
  {
    try {
      (arg1)->setBillboardRotationType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_billboard_rotation_type

  call-seq:
    get_billboard_rotation_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_billboard_rotation_type(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);
  {
    try {
      result = (Ogre::BillboardRotationType)((Ogre::BillboardSet const *)arg1)->getBillboardRotationType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_default_dimensions

  call-seq:
    set_default_dimensions(Real width, Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_default_dimensions(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);
  {
    try {
      (arg1)->setDefaultDimensions(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_default_width

  call-seq:
    set_default_width(Real width)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_default_width(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);
  {
    try {
      (arg1)->setDefaultWidth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_default_width

  call-seq:
    get_default_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_default_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::BillboardSet const *)arg1)->getDefaultWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_default_height

  call-seq:
    set_default_height(Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_default_height(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);
  {
    try {
      (arg1)->setDefaultHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_default_height

  call-seq:
    get_default_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_default_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::BillboardSet const *)arg1)->getDefaultHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_material_name

  call-seq:
    set_material_name(String name, String groupName=AUTODETECT_RESOURCE_GROUP_NAME)
    set_material_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardSet_set_material_name(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_set_material_name__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_set_material_name__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardSet.set_material_name", 
    "    void BillboardSet.set_material_name(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    void BillboardSet.set_material_name(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_material_name

  call-seq:
    get_material_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_material_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::BillboardSet const *)arg1)->getMaterialName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet._notify_current_camera

  call-seq:
    _notify_current_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet__notify_current_camera(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);
  {
    try {
      (arg1)->_notifyCurrentCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.begin_billboards

  call-seq:
    begin_billboards(size_t numBillboards=0)
    begin_billboards

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_begin_billboards__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);
  {
    try {
      (arg1)->beginBillboards(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_begin_billboards__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);
  {
    try {
      (arg1)->beginBillboards();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardSet_begin_billboards(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_begin_billboards__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_begin_billboards__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "BillboardSet.begin_billboards", 
    "    void BillboardSet.begin_billboards(size_t numBillboards)\n"
    "    void BillboardSet.begin_billboards()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.inject_billboard

  call-seq:
    inject_billboard(Billboard bb)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_inject_billboard(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);
  {
    try {
      (arg1)->injectBillboard((Ogre::Billboard const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.end_billboards

  call-seq:
    end_billboards

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_end_billboards(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);
  {
    try {
      (arg1)->endBillboards();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_bounds

  call-seq:
    set_bounds(AxisAlignedBox box, Real radius)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_bounds(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);
  {
    try {
      (arg1)->setBounds((Ogre::AxisAlignedBox const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::BillboardSet const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::BillboardSet const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::BillboardSet const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_material

  call-seq:
    set_material(MaterialPtr material)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_material(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);
  {
    try {
      (arg1)->setMaterial((Ogre::MaterialPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_render_operation

  call-seq:
    get_render_operation(RenderOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_render_operation(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);
  {
    try {
      (arg1)->getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_world_transforms(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);
  {
    try {
      ((Ogre::BillboardSet const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet._notify_billboard_resized

  call-seq:
    _notify_billboard_resized

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet__notify_billboard_resized(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);
  {
    try {
      (arg1)->_notifyBillboardResized();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet._notify_billboard_rotated

  call-seq:
    _notify_billboard_rotated

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet__notify_billboard_rotated(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);
  {
    try {
      (arg1)->_notifyBillboardRotated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_cull_individually

  call-seq:
    get_cull_individually -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_cull_individually(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);
  {
    try {
      result = (bool)((Ogre::BillboardSet const *)arg1)->getCullIndividually();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_cull_individually

  call-seq:
    set_cull_individually(bool cullIndividual)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_cull_individually(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);
  {
    try {
      (arg1)->setCullIndividually(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_billboard_type

  call-seq:
    set_billboard_type(BillboardType bbt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_billboard_type(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);
  {
    try {
      (arg1)->setBillboardType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_billboard_type

  call-seq:
    get_billboard_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_billboard_type(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);
  {
    try {
      result = (Ogre::BillboardType)((Ogre::BillboardSet const *)arg1)->getBillboardType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_common_direction

  call-seq:
    set_common_direction(Vector3 vec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_common_direction(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);
  {
    try {
      (arg1)->setCommonDirection((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_common_direction

  call-seq:
    get_common_direction -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_common_direction(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::BillboardSet const *)arg1)->getCommonDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_common_up_vector

  call-seq:
    set_common_up_vector(Vector3 vec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_common_up_vector(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);
  {
    try {
      (arg1)->setCommonUpVector((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_common_up_vector

  call-seq:
    get_common_up_vector -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_common_up_vector(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::BillboardSet const *)arg1)->getCommonUpVector();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_use_accurate_facing

  call-seq:
    set_use_accurate_facing(bool acc)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_use_accurate_facing(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);
  {
    try {
      (arg1)->setUseAccurateFacing(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_use_accurate_facing

  call-seq:
    get_use_accurate_facing -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_use_accurate_facing(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);
  {
    try {
      result = (bool)((Ogre::BillboardSet const *)arg1)->getUseAccurateFacing();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::BillboardSet const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera cam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::BillboardSet const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet._update_bounds

  call-seq:
    _update_bounds

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet__update_bounds(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);
  {
    try {
      (arg1)->_updateBounds();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_lights

  call-seq:
    get_lights -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_lights(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::BillboardSet const *)arg1)->getLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardSet_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardSet.visit_renderables", 
    "    void BillboardSet.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void BillboardSet.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet._sort_billboards

  call-seq:
    _sort_billboards(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet__sort_billboards(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);
  {
    try {
      (arg1)->_sortBillboards(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet._get_sort_mode

  call-seq:
    _get_sort_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet__get_sort_mode(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);
  {
    try {
      result = (Ogre::SortMode)((Ogre::BillboardSet const *)arg1)->_getSortMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_billboards_in_world_space

  call-seq:
    set_billboards_in_world_space(bool ws)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_billboards_in_world_space(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);
  {
    try {
      (arg1)->setBillboardsInWorldSpace(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_texture_coords

  call-seq:
    set_texture_coords(FloatRect coords, uint16 numCoords)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_texture_coords(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);
  {
    try {
      (arg1)->setTextureCoords((Ogre::FloatRect const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_texture_stacks_and_slices

  call-seq:
    set_texture_stacks_and_slices(uchar stacks, uchar slices)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_texture_stacks_and_slices(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);
  {
    try {
      (arg1)->setTextureStacksAndSlices(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_texture_coords

  call-seq:
    get_texture_coords(uint16 oNumCoords) -> FloatRect

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_texture_coords(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);
  {
    try {
      result = (Ogre::FloatRect *)(arg1)->getTextureCoords(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TRectT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_point_rendering_enabled

  call-seq:
    set_point_rendering_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_point_rendering_enabled(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);
  {
    try {
      (arg1)->setPointRenderingEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.is_point_rendering_enabled

  call-seq:
    is_point_rendering_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_is_point_rendering_enabled(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);
  {
    try {
      result = (bool)((Ogre::BillboardSet const *)arg1)->isPointRenderingEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_type_flags

  call-seq:
    get_type_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_type_flags(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::BillboardSet const *)arg1)->getTypeFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.set_auto_update

  call-seq:
    set_auto_update(bool autoUpdate)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_set_auto_update(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);
  {
    try {
      (arg1)->setAutoUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.get_auto_update

  call-seq:
    get_auto_update -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_get_auto_update(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);
  {
    try {
      result = (bool)((Ogre::BillboardSet const *)arg1)->getAutoUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.notify_billboard_data_changed

  call-seq:
    notify_billboard_data_changed

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSet_notify_billboard_data_changed(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);
  {
    try {
      (arg1)->notifyBillboardDataChanged();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::BillboardSetFactory < Ogre::Ogre::MovableObjectFactory

  Proxy of C++ Ogre::BillboardSetFactory class


*/
swig_class SwigClassBillboardSetFactory;

SWIGINTERN void
free_Ogre_BillboardSetFactory(Ogre::BillboardSetFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::BillboardSetFactory.FACTORY_TYPE_NAME

  call-seq:
    FACTORY_TYPE_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::BillboardSetFactory.FACTORY_TYPE_NAME=

  call-seq:
    FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::BillboardSetFactory.BillboardSetFactory_FACTORY_TYPE_NAME

  call-seq:
    BillboardSetFactory_FACTORY_TYPE_NAME -> String

Get value of attribute.

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



/*
  Document-method: Ogre::BillboardSetFactory.BillboardSetFactory_FACTORY_TYPE_NAME=

  call-seq:
    BillboardSetFactory_FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::BillboardSetFactory.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSetFactory_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::BillboardSetFactory const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSetFactory.destroy_instance

  call-seq:
    destroy_instance(MovableObject obj)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardSetFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::BillboardParticleRenderer < Ogre::Ogre::ParticleSystemRenderer

  Proxy of C++ Ogre::BillboardParticleRenderer class


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


/*
  Document-method: Ogre::BillboardParticleRenderer.new

  call-seq:
    BillboardParticleRenderer.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::BillboardParticleRenderer *)new Ogre::BillboardParticleRenderer();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_BillboardParticleRenderer(Ogre::BillboardParticleRenderer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::BillboardParticleRenderer.set_billboard_type

  call-seq:
    set_billboard_type(BillboardType bbt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_set_billboard_type(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);
  {
    try {
      (arg1)->setBillboardType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.get_billboard_type

  call-seq:
    get_billboard_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_get_billboard_type(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);
  {
    try {
      result = (Ogre::BillboardType)((Ogre::BillboardParticleRenderer const *)arg1)->getBillboardType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.set_use_accurate_facing

  call-seq:
    set_use_accurate_facing(bool acc)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_set_use_accurate_facing(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);
  {
    try {
      (arg1)->setUseAccurateFacing(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.get_use_accurate_facing

  call-seq:
    get_use_accurate_facing -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_get_use_accurate_facing(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);
  {
    try {
      result = (bool)((Ogre::BillboardParticleRenderer const *)arg1)->getUseAccurateFacing();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.set_billboard_origin

  call-seq:
    set_billboard_origin(BillboardOrigin origin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_set_billboard_origin(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);
  {
    try {
      (arg1)->setBillboardOrigin(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.get_billboard_origin

  call-seq:
    get_billboard_origin -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_get_billboard_origin(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);
  {
    try {
      result = (Ogre::BillboardOrigin)((Ogre::BillboardParticleRenderer const *)arg1)->getBillboardOrigin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.set_billboard_rotation_type

  call-seq:
    set_billboard_rotation_type(BillboardRotationType rotationType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_set_billboard_rotation_type(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);
  {
    try {
      (arg1)->setBillboardRotationType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.get_billboard_rotation_type

  call-seq:
    get_billboard_rotation_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_get_billboard_rotation_type(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);
  {
    try {
      result = (Ogre::BillboardRotationType)((Ogre::BillboardParticleRenderer const *)arg1)->getBillboardRotationType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.set_common_direction

  call-seq:
    set_common_direction(Vector3 vec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_set_common_direction(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);
  {
    try {
      (arg1)->setCommonDirection((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.get_common_direction

  call-seq:
    get_common_direction -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_get_common_direction(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::BillboardParticleRenderer const *)arg1)->getCommonDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.set_common_up_vector

  call-seq:
    set_common_up_vector(Vector3 vec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_set_common_up_vector(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);
  {
    try {
      (arg1)->setCommonUpVector((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.get_common_up_vector

  call-seq:
    get_common_up_vector -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_get_common_up_vector(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::BillboardParticleRenderer const *)arg1)->getCommonUpVector();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.set_point_rendering_enabled

  call-seq:
    set_point_rendering_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_set_point_rendering_enabled(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);
  {
    try {
      (arg1)->setPointRenderingEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.is_point_rendering_enabled

  call-seq:
    is_point_rendering_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_is_point_rendering_enabled(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);
  {
    try {
      result = (bool)((Ogre::BillboardParticleRenderer const *)arg1)->isPointRenderingEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::BillboardParticleRenderer const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue, Ogre::list<(p.Ogre::Particle,Ogre::STLAllocator<(p.Ogre::Particle,Ogre::GeneralAllocPolicy)>)>::type currentParticles, 
    bool cullIndividually)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2,*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardParticleRenderer_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardParticleRenderer.visit_renderables", 
    "    void BillboardParticleRenderer.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void BillboardParticleRenderer.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer._set_material

  call-seq:
    _set_material(MaterialPtr mat)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__set_material(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);
  {
    try {
      (arg1)->_setMaterial(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer._notify_current_camera

  call-seq:
    _notify_current_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notify_current_camera(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);
  {
    try {
      (arg1)->_notifyCurrentCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer._notify_particle_rotated

  call-seq:
    _notify_particle_rotated

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notify_particle_rotated(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);
  {
    try {
      (arg1)->_notifyParticleRotated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer._notify_particle_resized

  call-seq:
    _notify_particle_resized

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notify_particle_resized(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);
  {
    try {
      (arg1)->_notifyParticleResized();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer._notify_particle_quota

  call-seq:
    _notify_particle_quota(size_t quota)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notify_particle_quota(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);
  {
    try {
      (arg1)->_notifyParticleQuota(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer._notify_attached

  call-seq:
    _notify_attached(Node parent, bool isTagPoint=false)
    _notify_attached(Node parent)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardParticleRenderer__notify_attached(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__notify_attached__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__notify_attached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardParticleRenderer._notify_attached", 
    "    void BillboardParticleRenderer._notify_attached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void BillboardParticleRenderer._notify_attached(Ogre::Node *parent)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer._notify_default_dimensions

  call-seq:
    _notify_default_dimensions(Real width, Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notify_default_dimensions(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);
  {
    try {
      (arg1)->_notifyDefaultDimensions(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.set_render_queue_group

  call-seq:
    set_render_queue_group(uint8 queueID)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_set_render_queue_group(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);
  {
    try {
      (arg1)->setRenderQueueGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.set_render_queue_group_and_priority

  call-seq:
    set_render_queue_group_and_priority(uint8 queueID, ushort priority)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_set_render_queue_group_and_priority(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 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__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","setRenderQueueGroupAndPriority", 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","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);
  {
    try {
      (arg1)->setRenderQueueGroupAndPriority(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.set_keep_particles_in_local_space

  call-seq:
    set_keep_particles_in_local_space(bool keepLocal)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_set_keep_particles_in_local_space(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);
  {
    try {
      (arg1)->setKeepParticlesInLocalSpace(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer._get_sort_mode

  call-seq:
    _get_sort_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__get_sort_mode(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);
  {
    try {
      result = (Ogre::SortMode)((Ogre::BillboardParticleRenderer const *)arg1)->_getSortMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRenderer.get_billboard_set

  call-seq:
    get_billboard_set -> BillboardSet

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_get_billboard_set(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);
  {
    try {
      result = (Ogre::BillboardSet *)((Ogre::BillboardParticleRenderer const *)arg1)->getBillboardSet();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::BillboardParticleRendererFactory < Ogre::Ogre::ParticleSystemRendererFactory

  Proxy of C++ Ogre::BillboardParticleRendererFactory class


*/
swig_class SwigClassBillboardParticleRendererFactory;


/*
  Document-method: Ogre::BillboardParticleRendererFactory.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRendererFactory_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::BillboardParticleRendererFactory const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRendererFactory.create_instance

  call-seq:
    create_instance(String name) -> ParticleSystemRenderer

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRendererFactory_create_instance(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;
  }
  {
    try {
      result = (Ogre::ParticleSystemRenderer *)(arg1)->createInstance((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::BillboardParticleRendererFactory.destroy_instance

  call-seq:
    destroy_instance(ParticleSystemRenderer inst)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BillboardParticleRendererFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::BillboardParticleRendererFactory.new

  call-seq:
    BillboardParticleRendererFactory.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::BillboardParticleRendererFactory *)new Ogre::BillboardParticleRendererFactory();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_BillboardParticleRendererFactory(Ogre::BillboardParticleRendererFactory *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::Bitwise

  Proxy of C++ Ogre::Bitwise class


*/
swig_class SwigClassBitwise;


/*
  Document-method: Ogre::Bitwise.most_significant_bit_set

  call-seq:
    most_significant_bit_set(unsigned int value) -> unsigned int

A class method.

*/
SWIGINTERN VALUE
_wrap_Bitwise_most_significant_bit_set(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);
  {
    try {
      result = (unsigned int)Ogre::Bitwise::mostSignificantBitSet(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bitwise.first_po_2from

  call-seq:
    first_po_2from(uint32 n) -> uint32

A class method.

*/
SWIGINTERN VALUE
_wrap_Bitwise_first_po_2from(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);
  {
    try {
      result = (Ogre::uint32)Ogre::Bitwise::firstPO2From(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bitwise.fixed_to_fixed

  call-seq:
    fixed_to_fixed(uint32 value, unsigned int n, unsigned int p) -> unsigned int

A class method.

*/
SWIGINTERN VALUE
_wrap_Bitwise_fixed_to_fixed(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);
  {
    try {
      result = (unsigned int)Ogre::Bitwise::fixedToFixed(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bitwise.float_to_fixed

  call-seq:
    float_to_fixed(float value, unsigned int bits) -> unsigned int

A class method.

*/
SWIGINTERN VALUE
_wrap_Bitwise_float_to_fixed(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);
  {
    try {
      result = (unsigned int)Ogre::Bitwise::floatToFixed(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bitwise.fixed_to_float

  call-seq:
    fixed_to_float(unsigned int value, unsigned int bits) -> float

A class method.

*/
SWIGINTERN VALUE
_wrap_Bitwise_fixed_to_float(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);
  {
    try {
      result = (float)Ogre::Bitwise::fixedToFloat(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bitwise.int_write

  call-seq:
    int_write(void dest, int n, unsigned int value)

A class method.

*/
SWIGINTERN VALUE
_wrap_Bitwise_int_write(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);
  {
    try {
      Ogre::Bitwise::intWrite(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bitwise.int_read

  call-seq:
    int_read(void src, int n) -> unsigned int

A class method.

*/
SWIGINTERN VALUE
_wrap_Bitwise_int_read(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);
  {
    try {
      result = (unsigned int)Ogre::Bitwise::intRead((void const *)arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bitwise.float_to_half

  call-seq:
    float_to_half(float i) -> uint16

A class method.

*/
SWIGINTERN VALUE
_wrap_Bitwise_float_to_half(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);
  {
    try {
      result = (Ogre::uint16)Ogre::Bitwise::floatToHalf(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bitwise.float_to_half_i

  call-seq:
    float_to_half_i(uint32 i) -> uint16

A class method.

*/
SWIGINTERN VALUE
_wrap_Bitwise_float_to_half_i(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);
  {
    try {
      result = (Ogre::uint16)Ogre::Bitwise::floatToHalfI(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bitwise.half_to_float

  call-seq:
    half_to_float(uint16 y) -> float

A class method.

*/
SWIGINTERN VALUE
_wrap_Bitwise_half_to_float(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);
  {
    try {
      result = (float)Ogre::Bitwise::halfToFloat(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bitwise.half_to_float_i

  call-seq:
    half_to_float_i(uint16 y) -> uint32

A class method.

*/
SWIGINTERN VALUE
_wrap_Bitwise_half_to_float_i(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);
  {
    try {
      result = (Ogre::uint32)Ogre::Bitwise::halfToFloatI(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
  }
  


/*
  Document-method: Ogre::Bitwise.new

  call-seq:
    Bitwise.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Bitwise *)new Ogre::Bitwise();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Bitwise(Ogre::Bitwise *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::Skeleton < Ogre::Ogre::Resource, Ogre::Ogre::AnimationContainer

  Proxy of C++ Ogre::Skeleton class


*/
swig_class SwigClassSkeleton;


/*
  Document-method: Ogre::Skeleton.new

  call-seq:
    Skeleton.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual=false, 
    ManualResourceLoader loader=0)
    Skeleton.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual=false)
    Skeleton.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Skeleton *)new Ogre::Skeleton(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Skeleton *)new Ogre::Skeleton(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Skeleton *)new Ogre::Skeleton(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::Skeleton.create_bone

  call-seq:
    create_bone -> Bone
    create_bone(unsigned short handle) -> Bone
    create_bone(String name) -> Bone
    create_bone(String name, unsigned short handle) -> Bone

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_create_bone__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);
  {
    try {
      result = (Ogre::Bone *)(arg1)->createBone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_create_bone__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);
  {
    try {
      result = (Ogre::Bone *)(arg1)->createBone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_create_bone__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;
  }
  {
    try {
      result = (Ogre::Bone *)(arg1)->createBone((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_bone__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);
  {
    try {
      result = (Ogre::Bone *)(arg1)->createBone((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_bone(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_create_bone__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_create_bone__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_create_bone__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_create_bone__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Skeleton.create_bone", 
    "    Ogre::Bone * Skeleton.create_bone()\n"
    "    Ogre::Bone * Skeleton.create_bone(unsigned short handle)\n"
    "    Ogre::Bone * Skeleton.create_bone(Ogre::String const &name)\n"
    "    Ogre::Bone * Skeleton.create_bone(Ogre::String const &name, unsigned short handle)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.get_num_bones

  call-seq:
    get_num_bones -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_get_num_bones(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);
  {
    try {
      result = (unsigned short)((Ogre::Skeleton const *)arg1)->getNumBones();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.get_root_bone

  call-seq:
    get_root_bone -> Bone

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_get_root_bone(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);
  {
    try {
      result = (Ogre::Bone *)((Ogre::Skeleton const *)arg1)->getRootBone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.get_root_bone_iterator

  call-seq:
    get_root_bone_iterator -> BoneIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_get_root_bone_iterator(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);
  {
    try {
      result = (arg1)->getRootBoneIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Skeleton.get_bone_iterator

  call-seq:
    get_bone_iterator -> BoneIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_get_bone_iterator(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);
  {
    try {
      result = (arg1)->getBoneIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Skeleton.get_bone

  call-seq:
    get_bone(unsigned short handle) -> Bone
    get_bone(String name) -> Bone

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_get_bone__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);
  {
    try {
      result = (Ogre::Bone *)((Ogre::Skeleton const *)arg1)->getBone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_get_bone__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;
  }
  {
    try {
      result = (Ogre::Bone *)((Ogre::Skeleton const *)arg1)->getBone((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_bone(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_get_bone__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_get_bone__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Skeleton.get_bone", 
    "    Ogre::Bone * Skeleton.get_bone(unsigned short handle)\n"
    "    Ogre::Bone * Skeleton.get_bone(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.has_bone

  call-seq:
    has_bone(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_has_bone(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;
  }
  {
    try {
      result = (bool)((Ogre::Skeleton const *)arg1)->hasBone((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.set_binding_pose

  call-seq:
    set_binding_pose

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_set_binding_pose(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);
  {
    try {
      (arg1)->setBindingPose();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.reset

  call-seq:
    reset(bool resetManualBones=false)
    reset

An instance method.

*/
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);
  {
    try {
      (arg1)->reset(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Skeleton.create_animation

  call-seq:
    create_animation(String name, Real length) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_create_animation(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);
  {
    try {
      result = (Ogre::Animation *)(arg1)->createAnimation((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.get_animation

  call-seq:
    get_animation(String name, LinkedSkeletonAnimationSource linker) -> Animation
    get_animation(String name) -> Animation
    get_animation(unsigned short index) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_get_animation__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);
  {
    try {
      result = (Ogre::Animation *)((Ogre::Skeleton const *)arg1)->getAnimation((Ogre::String const &)*arg2,(Ogre::LinkedSkeletonAnimationSource const **)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_animation__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;
  }
  {
    try {
      result = (Ogre::Animation *)((Ogre::Skeleton const *)arg1)->getAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton._get_animation_impl

  call-seq:
    _get_animation_impl(String name, LinkedSkeletonAnimationSource linker=0) -> Animation
    _get_animation_impl(String name) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton__get_animation_impl__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);
  {
    try {
      result = (Ogre::Animation *)((Ogre::Skeleton const *)arg1)->_getAnimationImpl((Ogre::String const &)*arg2,(Ogre::LinkedSkeletonAnimationSource const **)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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__get_animation_impl__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;
  }
  {
    try {
      result = (Ogre::Animation *)((Ogre::Skeleton const *)arg1)->_getAnimationImpl((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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__get_animation_impl(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__get_animation_impl__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__get_animation_impl__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Skeleton._get_animation_impl", 
    "    Ogre::Animation * Skeleton._get_animation_impl(Ogre::String const &name, Ogre::LinkedSkeletonAnimationSource const **linker)\n"
    "    Ogre::Animation * Skeleton._get_animation_impl(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.has_animation

  call-seq:
    has_animation(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_has_animation(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;
  }
  {
    try {
      result = (bool)((Ogre::Skeleton const *)arg1)->hasAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.remove_animation

  call-seq:
    remove_animation(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_remove_animation(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;
  }
  {
    try {
      (arg1)->removeAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.set_animation_state

  call-seq:
    set_animation_state(AnimationStateSet animSet)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_set_animation_state(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);
  {
    try {
      (arg1)->setAnimationState((Ogre::AnimationStateSet const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton._init_animation_state

  call-seq:
    _init_animation_state(AnimationStateSet animSet)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton__init_animation_state(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);
  {
    try {
      (arg1)->_initAnimationState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton._refresh_animation_state

  call-seq:
    _refresh_animation_state(AnimationStateSet animSet)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton__refresh_animation_state(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);
  {
    try {
      (arg1)->_refreshAnimationState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton._get_bone_matrices

  call-seq:
    _get_bone_matrices(Matrix4 pMatrices)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton__get_bone_matrices(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);
  {
    try {
      (arg1)->_getBoneMatrices(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.get_num_animations

  call-seq:
    get_num_animations -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_get_num_animations(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);
  {
    try {
      result = (unsigned short)((Ogre::Skeleton const *)arg1)->getNumAnimations();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.get_animation

  call-seq:
    get_animation(String name, LinkedSkeletonAnimationSource linker) -> Animation
    get_animation(String name) -> Animation
    get_animation(unsigned short index) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_get_animation__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);
  {
    try {
      result = (Ogre::Animation *)((Ogre::Skeleton const *)arg1)->getAnimation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Skeleton_get_animation(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_get_animation__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_get_animation__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_get_animation__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Skeleton.get_animation", 
    "    Ogre::Animation * Skeleton.get_animation(Ogre::String const &name, Ogre::LinkedSkeletonAnimationSource const **linker)\n"
    "    Ogre::Animation * Skeleton.get_animation(Ogre::String const &name)\n"
    "    Ogre::Animation * Skeleton.get_animation(unsigned short index)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.get_blend_mode

  call-seq:
    get_blend_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_get_blend_mode(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);
  {
    try {
      result = (Ogre::SkeletonAnimationBlendMode)((Ogre::Skeleton const *)arg1)->getBlendMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.set_blend_mode

  call-seq:
    set_blend_mode(SkeletonAnimationBlendMode state)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_set_blend_mode(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);
  {
    try {
      (arg1)->setBlendMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton._update_transforms

  call-seq:
    _update_transforms

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton__update_transforms(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);
  {
    try {
      (arg1)->_updateTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.optimise_all_animations

  call-seq:
    optimise_all_animations(bool preservingIdentityNodeTracks=false)
    optimise_all_animations

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_optimise_all_animations__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);
  {
    try {
      (arg1)->optimiseAllAnimations(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_optimise_all_animations__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);
  {
    try {
      (arg1)->optimiseAllAnimations();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Skeleton_optimise_all_animations(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_optimise_all_animations__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_optimise_all_animations__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Skeleton.optimise_all_animations", 
    "    void Skeleton.optimise_all_animations(bool preservingIdentityNodeTracks)\n"
    "    void Skeleton.optimise_all_animations()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.add_linked_skeleton_animation_source

  call-seq:
    add_linked_skeleton_animation_source(String skelName, Real scale=1.0)
    add_linked_skeleton_animation_source(String skelName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_add_linked_skeleton_animation_source__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);
  {
    try {
      (arg1)->addLinkedSkeletonAnimationSource((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_add_linked_skeleton_animation_source__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;
  }
  {
    try {
      (arg1)->addLinkedSkeletonAnimationSource((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Skeleton_add_linked_skeleton_animation_source(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_add_linked_skeleton_animation_source__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_add_linked_skeleton_animation_source__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Skeleton.add_linked_skeleton_animation_source", 
    "    void Skeleton.add_linked_skeleton_animation_source(Ogre::String const &skelName, Ogre::Real scale)\n"
    "    void Skeleton.add_linked_skeleton_animation_source(Ogre::String const &skelName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.remove_all_linked_skeleton_animation_sources

  call-seq:
    remove_all_linked_skeleton_animation_sources

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_remove_all_linked_skeleton_animation_sources(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);
  {
    try {
      (arg1)->removeAllLinkedSkeletonAnimationSources();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.get_linked_skeleton_animation_source_iterator

  call-seq:
    get_linked_skeleton_animation_source_iterator -> LinkedSkeletonAnimSourceIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_get_linked_skeleton_animation_source_iterator(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);
  {
    try {
      result = ((Ogre::Skeleton const *)arg1)->getLinkedSkeletonAnimationSourceIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Skeleton._notify_manual_bones_dirty

  call-seq:
    _notify_manual_bones_dirty

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton__notify_manual_bones_dirty(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);
  {
    try {
      (arg1)->_notifyManualBonesDirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton._notify_manual_bone_state_change

  call-seq:
    _notify_manual_bone_state_change(Bone bone)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton__notify_manual_bone_state_change(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);
  {
    try {
      (arg1)->_notifyManualBoneStateChange(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.get_manual_bones_dirty

  call-seq:
    get_manual_bones_dirty -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_get_manual_bones_dirty(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);
  {
    try {
      result = (bool)((Ogre::Skeleton const *)arg1)->getManualBonesDirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton.has_manual_bones

  call-seq:
    has_manual_bones -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton_has_manual_bones(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);
  {
    try {
      result = (bool)((Ogre::Skeleton const *)arg1)->hasManualBones();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton._merge_skeleton_animations

  call-seq:
    _merge_skeleton_animations(Skeleton source, BoneHandleMap boneHandleMap, StringVector animations=Ogre::StringVector())
    _merge_skeleton_animations(Skeleton source, BoneHandleMap boneHandleMap)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton__merge_skeleton_animations__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);
  {
    try {
      (arg1)->_mergeSkeletonAnimations((Ogre::Skeleton const *)arg2,(Ogre::Skeleton::BoneHandleMap const &)*arg3,(Ogre::StringVector const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__merge_skeleton_animations__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);
  {
    try {
      (arg1)->_mergeSkeletonAnimations((Ogre::Skeleton const *)arg2,(Ogre::Skeleton::BoneHandleMap const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Skeleton__merge_skeleton_animations(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__merge_skeleton_animations__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__merge_skeleton_animations__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Skeleton._merge_skeleton_animations", 
    "    void Skeleton._merge_skeleton_animations(Ogre::Skeleton const *source, Ogre::Skeleton::BoneHandleMap const &boneHandleMap, Ogre::StringVector const &animations)\n"
    "    void Skeleton._merge_skeleton_animations(Ogre::Skeleton const *source, Ogre::Skeleton::BoneHandleMap const &boneHandleMap)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton._build_map_bone_by_handle

  call-seq:
    _build_map_bone_by_handle(Skeleton source, BoneHandleMap boneHandleMap)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton__build_map_bone_by_handle(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);
  {
    try {
      ((Ogre::Skeleton const *)arg1)->_buildMapBoneByHandle((Ogre::Skeleton const *)arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Skeleton._build_map_bone_by_name

  call-seq:
    _build_map_bone_by_name(Skeleton source, BoneHandleMap boneHandleMap)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Skeleton__build_map_bone_by_name(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);
  {
    try {
      ((Ogre::Skeleton const *)arg1)->_buildMapBoneByName((Ogre::Skeleton const *)arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::SkeletonPtr

  Proxy of C++ Ogre::SkeletonPtr class


*/
swig_class SwigClassSkeletonPtr;


/*
  Document-method: Ogre::SkeletonPtr.new

  call-seq:
    SkeletonPtr.new
    SkeletonPtr.new(Skeleton rep)
    SkeletonPtr.new(SkeletonPtr r)
    SkeletonPtr.new(ResourcePtr r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SkeletonPtr *)new Ogre::SkeletonPtr();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::SkeletonPtr *)new Ogre::SkeletonPtr(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::SkeletonPtr *)new Ogre::SkeletonPtr((Ogre::SkeletonPtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::SkeletonPtr *)new Ogre::SkeletonPtr((Ogre::ResourcePtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::LinkedSkeletonAnimationSource

  Proxy of C++ Ogre::LinkedSkeletonAnimationSource class


*/
swig_class SwigClassLinkedSkeletonAnimationSource;


/*
  Document-method: Ogre::LinkedSkeletonAnimationSource.skeletonName

  call-seq:
    skeletonName -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::LinkedSkeletonAnimationSource.skeletonName=

  call-seq:
    skeletonName=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::LinkedSkeletonAnimationSource.pSkeleton

  call-seq:
    pSkeleton -> SkeletonPtr

Get value of attribute.

*/

/*
  Document-method: Ogre::LinkedSkeletonAnimationSource.pSkeleton=

  call-seq:
    pSkeleton=(x) -> SkeletonPtr

Set new value for attribute.

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



/*
  Document-method: Ogre::LinkedSkeletonAnimationSource.scale

  call-seq:
    scale -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::LinkedSkeletonAnimationSource.scale=

  call-seq:
    scale=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::LinkedSkeletonAnimationSource.new

  call-seq:
    LinkedSkeletonAnimationSource.new(String skelName, Real scl)
    LinkedSkeletonAnimationSource.new(String skelName, Real scl, SkeletonPtr skelPtr)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::LinkedSkeletonAnimationSource *)new Ogre::LinkedSkeletonAnimationSource((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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));
    }
  }
  {
    try {
      result = (Ogre::LinkedSkeletonAnimationSource *)new Ogre::LinkedSkeletonAnimationSource((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::MeshSharedPtr

  Proxy of C++ Ogre::MeshSharedPtr class


*/
swig_class SwigClassMeshSharedPtr;


/*
  Document-method: Ogre::MeshSharedPtr.new

  call-seq:
    MeshSharedPtr.new
    MeshSharedPtr.new(MeshSharedPtr r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SharedPtr< Ogre::Mesh > *)new Ogre::SharedPtr< Ogre::Mesh >();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::SharedPtr< Ogre::Mesh > *)new Ogre::SharedPtr< Ogre::Mesh >((Ogre::SharedPtr< Ogre::Mesh > const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::MeshSharedPtr.__ref__

  call-seq:
    __ref__ -> Mesh

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Mesh *) &((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->operator *();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshSharedPtr.__deref__

  call-seq:
    __deref__ -> Mesh

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Mesh *)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->operator ->();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshSharedPtr.get

  call-seq:
    get -> Mesh

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Mesh *)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->get();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshSharedPtr.bind

  call-seq:
    bind(Mesh rep, SharedPtrFreeMethod inFreeMethod=SPFM_DELETE)
    bind(Mesh rep)

An instance method.

*/
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);
  {
    try {
      (arg1)->bind(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->bind(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::MeshSharedPtr.unique

  call-seq:
    unique -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->unique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshSharedPtr.use_count

  call-seq:
    use_count -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_use_count(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);
  {
    try {
      result = (unsigned int)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->useCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshSharedPtr.use_count_pointer

  call-seq:
    use_count_pointer -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_use_count_pointer(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);
  {
    try {
      result = (unsigned int *)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->useCountPointer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshSharedPtr.get_pointer

  call-seq:
    get_pointer -> Mesh

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_pointer(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);
  {
    try {
      result = (Ogre::Mesh *)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->getPointer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshSharedPtr.free_method

  call-seq:
    free_method -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_free_method(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);
  {
    try {
      result = (Ogre::SharedPtrFreeMethod)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->freeMethod();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshSharedPtr.is_null

  call-seq:
    is_null -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_is_null(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);
  {
    try {
      result = (bool)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->isNull();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshSharedPtr.set_null

  call-seq:
    set_null

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_set_null(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);
  {
    try {
      (arg1)->setNull();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.create_sub_mesh

  call-seq:
    create_sub_mesh -> SubMesh
    create_sub_mesh(String name) -> SubMesh

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_create_sub_mesh__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);
  {
    try {
      result = (Ogre::SubMesh *)(*arg1)->createSubMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_create_sub_mesh__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;
  }
  {
    try {
      result = (Ogre::SubMesh *)(*arg1)->createSubMesh((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_sub_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MeshSharedPtr_create_sub_mesh__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_create_sub_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.create_sub_mesh", 
    "    Ogre::SubMesh * Mesh.create_sub_mesh()\n"
    "    Ogre::SubMesh * Mesh.create_sub_mesh(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.name_sub_mesh

  call-seq:
    name_sub_mesh(String name, ushort index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_name_sub_mesh(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);
  {
    try {
      (*arg1)->nameSubMesh((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.unname_sub_mesh

  call-seq:
    unname_sub_mesh(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_unname_sub_mesh(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;
  }
  {
    try {
      (*arg1)->unnameSubMesh((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._get_sub_mesh_index

  call-seq:
    _get_sub_mesh_index(String name) -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__get_sub_mesh_index(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;
  }
  {
    try {
      result = (Ogre::ushort)(*arg1)->_getSubMeshIndex((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::Mesh.get_num_sub_meshes

  call-seq:
    get_num_sub_meshes -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_num_sub_meshes(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);
  {
    try {
      result = (unsigned short)(*arg1)->getNumSubMeshes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_sub_mesh

  call-seq:
    get_sub_mesh(unsigned short index) -> SubMesh
    get_sub_mesh(String name) -> SubMesh

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_sub_mesh__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);
  {
    try {
      result = (Ogre::SubMesh *)(*arg1)->getSubMesh(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_sub_mesh__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;
  }
  {
    try {
      result = (Ogre::SubMesh *)(*arg1)->getSubMesh((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_sub_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 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_get_sub_mesh__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_get_sub_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.get_sub_mesh", 
    "    Ogre::SubMesh * Mesh.get_sub_mesh(unsigned short index)\n"
    "    Ogre::SubMesh * Mesh.get_sub_mesh(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.destroy_sub_mesh

  call-seq:
    destroy_sub_mesh(unsigned short index)
    destroy_sub_mesh(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_destroy_sub_mesh__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);
  {
    try {
      (*arg1)->destroySubMesh(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_destroy_sub_mesh__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;
  }
  {
    try {
      (*arg1)->destroySubMesh((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_destroy_sub_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 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_destroy_sub_mesh__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_destroy_sub_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.destroy_sub_mesh", 
    "    void Mesh.destroy_sub_mesh(unsigned short index)\n"
    "    void Mesh.destroy_sub_mesh(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_sub_mesh_iterator

  call-seq:
    get_sub_mesh_iterator -> SubMeshIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_sub_mesh_iterator(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);
  {
    try {
      result = (*arg1)->getSubMeshIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Mesh.sharedVertexData

  call-seq:
    sharedVertexData -> VertexData

Get value of attribute.

*/

/*
  Document-method: Ogre::Mesh.sharedVertexData=

  call-seq:
    sharedVertexData=(x) -> VertexData

Set new value for attribute.

*/
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);
  {
    try {
      if (arg1) (*arg1)->sharedVertexData = arg2;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::VertexData *) ((*arg1)->sharedVertexData);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.sharedBlendIndexToBoneIndexMap

  call-seq:
    sharedBlendIndexToBoneIndexMap -> IndexMap

Get value of attribute.

*/

/*
  Document-method: Ogre::Mesh.sharedBlendIndexToBoneIndexMap=

  call-seq:
    sharedBlendIndexToBoneIndexMap=(x) -> IndexMap

Set new value for attribute.

*/
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);
  {
    try {
      if (arg1) (*arg1)->sharedBlendIndexToBoneIndexMap = *arg2;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Mesh::IndexMap *)& ((*arg1)->sharedBlendIndexToBoneIndexMap);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
  }
  {
    try {
      result = (*arg1)->clone((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      result = (*arg1)->clone((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Mesh.get_bounds

  call-seq:
    get_bounds -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_bounds(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &(*arg1)->getBounds();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_bounding_sphere_radius

  call-seq:
    get_bounding_sphere_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_bounding_sphere_radius(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);
  {
    try {
      result = (Ogre::Real)(*arg1)->getBoundingSphereRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._set_bounds

  call-seq:
    _set_bounds(AxisAlignedBox bounds, bool pad=true)
    _set_bounds(AxisAlignedBox bounds)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__set_bounds__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);
  {
    try {
      (*arg1)->_setBounds((Ogre::AxisAlignedBox const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__set_bounds__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);
  {
    try {
      (*arg1)->_setBounds((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr__set_bounds(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__set_bounds__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__set_bounds__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh._set_bounds", 
    "    void Mesh._set_bounds(Ogre::AxisAlignedBox const &bounds, bool pad)\n"
    "    void Mesh._set_bounds(Ogre::AxisAlignedBox const &bounds)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._set_bounding_sphere_radius

  call-seq:
    _set_bounding_sphere_radius(Real radius)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__set_bounding_sphere_radius(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);
  {
    try {
      (*arg1)->_setBoundingSphereRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.set_skeleton_name

  call-seq:
    set_skeleton_name(String skelName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_set_skeleton_name(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;
  }
  {
    try {
      (*arg1)->setSkeletonName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.has_skeleton

  call-seq:
    has_skeleton -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_has_skeleton(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);
  {
    try {
      result = (bool)(*arg1)->hasSkeleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.has_vertex_animation

  call-seq:
    has_vertex_animation -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_has_vertex_animation(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);
  {
    try {
      result = (bool)(*arg1)->hasVertexAnimation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_skeleton

  call-seq:
    get_skeleton -> SkeletonPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_skeleton(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);
  {
    try {
      result = (Ogre::SkeletonPtr *) &(*arg1)->getSkeleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_skeleton_name

  call-seq:
    get_skeleton_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_skeleton_name(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);
  {
    try {
      result = (Ogre::String *) &(*arg1)->getSkeletonName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._init_animation_state

  call-seq:
    _init_animation_state(AnimationStateSet animSet)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__init_animation_state(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);
  {
    try {
      (*arg1)->_initAnimationState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._refresh_animation_state

  call-seq:
    _refresh_animation_state(AnimationStateSet animSet)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__refresh_animation_state(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);
  {
    try {
      (*arg1)->_refreshAnimationState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.add_bone_assignment

  call-seq:
    add_bone_assignment(VertexBoneAssignment vertBoneAssign)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_add_bone_assignment(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);
  {
    try {
      (*arg1)->addBoneAssignment((Ogre::VertexBoneAssignment const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.clear_bone_assignments

  call-seq:
    clear_bone_assignments

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_clear_bone_assignments(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);
  {
    try {
      (*arg1)->clearBoneAssignments();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._notify_skeleton

  call-seq:
    _notify_skeleton(SkeletonPtr pSkel)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__notify_skeleton(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);
  {
    try {
      (*arg1)->_notifySkeleton(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_bone_assignment_iterator

  call-seq:
    get_bone_assignment_iterator -> BoneAssignmentIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_bone_assignment_iterator(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);
  {
    try {
      result = (*arg1)->getBoneAssignmentIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Mesh.get_bone_assignments

  call-seq:
    get_bone_assignments -> VertexBoneAssignmentList

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_bone_assignments(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);
  {
    try {
      result = (Ogre::Mesh::VertexBoneAssignmentList *) &(*arg1)->getBoneAssignments();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::Mesh.get_num_lod_levels

  call-seq:
    get_num_lod_levels -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_num_lod_levels(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);
  {
    try {
      result = (Ogre::ushort)(*arg1)->getNumLodLevels();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_lod_level

  call-seq:
    get_lod_level(ushort index) -> MeshLodUsage

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_lod_level(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);
  {
    try {
      result = (Ogre::MeshLodUsage *) &(*arg1)->getLodLevel(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshLodUsage, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.create_manual_lod_level

  call-seq:
    create_manual_lod_level(Real value, String meshName, String groupName=Ogre::String())
    create_manual_lod_level(Real value, String meshName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_create_manual_lod_level__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;
  }
  {
    try {
      (*arg1)->createManualLodLevel(arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_create_manual_lod_level__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;
  }
  {
    try {
      (*arg1)->createManualLodLevel(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_create_manual_lod_level(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_create_manual_lod_level__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_create_manual_lod_level__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Mesh.create_manual_lod_level", 
    "    void Mesh.create_manual_lod_level(Ogre::Real value, Ogre::String const &meshName, Ogre::String const &groupName)\n"
    "    void Mesh.create_manual_lod_level(Ogre::Real value, Ogre::String const &meshName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.update_manual_lod_level

  call-seq:
    update_manual_lod_level(ushort index, String meshName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_update_manual_lod_level(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;
  }
  {
    try {
      (*arg1)->updateManualLodLevel(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_lod_index

  call-seq:
    get_lod_index(Real value) -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_lod_index(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);
  {
    try {
      result = (Ogre::ushort)(*arg1)->getLodIndex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.is_lod_manual

  call-seq:
    is_lod_manual -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_is_lod_manual(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);
  {
    try {
      result = (bool)(*arg1)->isLodManual();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._set_lod_info

  call-seq:
    _set_lod_info(unsigned short numLevels, bool isManual)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__set_lod_info(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);
  {
    try {
      (*arg1)->_setLodInfo(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._set_lod_usage

  call-seq:
    _set_lod_usage(unsigned short level, MeshLodUsage usage)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__set_lod_usage(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);
  {
    try {
      (*arg1)->_setLodUsage(arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._set_sub_mesh_lod_face_list

  call-seq:
    _set_sub_mesh_lod_face_list(unsigned short subIdx, unsigned short level, IndexData facedata)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__set_sub_mesh_lod_face_list(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);
  {
    try {
      (*arg1)->_setSubMeshLodFaceList(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.remove_lod_levels

  call-seq:
    remove_lod_levels

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_remove_lod_levels(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);
  {
    try {
      (*arg1)->removeLodLevels();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.set_vertex_buffer_policy

  call-seq:
    set_vertex_buffer_policy(Usage usage, bool shadowBuffer=false)
    set_vertex_buffer_policy(Usage usage)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_set_vertex_buffer_policy__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);
  {
    try {
      (*arg1)->setVertexBufferPolicy(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_set_vertex_buffer_policy__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);
  {
    try {
      (*arg1)->setVertexBufferPolicy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_set_vertex_buffer_policy(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_set_vertex_buffer_policy__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_set_vertex_buffer_policy__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.set_vertex_buffer_policy", 
    "    void Mesh.set_vertex_buffer_policy(Ogre::HardwareBuffer::Usage usage, bool shadowBuffer)\n"
    "    void Mesh.set_vertex_buffer_policy(Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.set_index_buffer_policy

  call-seq:
    set_index_buffer_policy(Usage usage, bool shadowBuffer=false)
    set_index_buffer_policy(Usage usage)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_set_index_buffer_policy__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);
  {
    try {
      (*arg1)->setIndexBufferPolicy(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_set_index_buffer_policy__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);
  {
    try {
      (*arg1)->setIndexBufferPolicy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_set_index_buffer_policy(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_set_index_buffer_policy__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_set_index_buffer_policy__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.set_index_buffer_policy", 
    "    void Mesh.set_index_buffer_policy(Ogre::HardwareBuffer::Usage usage, bool shadowBuffer)\n"
    "    void Mesh.set_index_buffer_policy(Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_vertex_buffer_usage

  call-seq:
    get_vertex_buffer_usage -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_vertex_buffer_usage(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);
  {
    try {
      result = (Ogre::HardwareBuffer::Usage)(*arg1)->getVertexBufferUsage();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_index_buffer_usage

  call-seq:
    get_index_buffer_usage -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_index_buffer_usage(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);
  {
    try {
      result = (Ogre::HardwareBuffer::Usage)(*arg1)->getIndexBufferUsage();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.is_vertex_buffer_shadowed

  call-seq:
    is_vertex_buffer_shadowed -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_is_vertex_buffer_shadowed(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);
  {
    try {
      result = (bool)(*arg1)->isVertexBufferShadowed();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.is_index_buffer_shadowed

  call-seq:
    is_index_buffer_shadowed -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_is_index_buffer_shadowed(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);
  {
    try {
      result = (bool)(*arg1)->isIndexBufferShadowed();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._rationalise_bone_assignments

  call-seq:
    _rationalise_bone_assignments(size_t vertexCount, VertexBoneAssignmentList assignments) -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__rationalise_bone_assignments(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);
  {
    try {
      result = (unsigned short)(*arg1)->_rationaliseBoneAssignments(arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._compile_bone_assignments

  call-seq:
    _compile_bone_assignments

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__compile_bone_assignments(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);
  {
    try {
      (*arg1)->_compileBoneAssignments();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._update_compiled_bone_assignments

  call-seq:
    _update_compiled_bone_assignments

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__update_compiled_bone_assignments(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);
  {
    try {
      (*arg1)->_updateCompiledBoneAssignments();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.build_tangent_vectors

  call-seq:
    build_tangent_vectors(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0, 
    unsigned short index=0, 
    bool splitMirrored=false, bool splitRotated=false, 
    bool storeParityInW=false)
    build_tangent_vectors(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0, 
    unsigned short index=0, 
    bool splitMirrored=false, bool splitRotated=false)
    build_tangent_vectors(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0, 
    unsigned short index=0, 
    bool splitMirrored=false)
    build_tangent_vectors(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0, 
    unsigned short index=0)
    build_tangent_vectors(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0)
    build_tangent_vectors(VertexElementSemantic targetSemantic=VES_TANGENT)
    build_tangent_vectors

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_build_tangent_vectors__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);
  {
    try {
      (*arg1)->buildTangentVectors(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_build_tangent_vectors__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);
  {
    try {
      (*arg1)->buildTangentVectors(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_build_tangent_vectors__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);
  {
    try {
      (*arg1)->buildTangentVectors(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_build_tangent_vectors__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);
  {
    try {
      (*arg1)->buildTangentVectors(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_build_tangent_vectors__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);
  {
    try {
      (*arg1)->buildTangentVectors(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_build_tangent_vectors__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);
  {
    try {
      (*arg1)->buildTangentVectors(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_build_tangent_vectors__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);
  {
    try {
      (*arg1)->buildTangentVectors();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_build_tangent_vectors(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_build_tangent_vectors__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_build_tangent_vectors__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_build_tangent_vectors__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_build_tangent_vectors__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_build_tangent_vectors__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_build_tangent_vectors__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_build_tangent_vectors__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Mesh.build_tangent_vectors", 
    "    void Mesh.build_tangent_vectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index, bool splitMirrored, bool splitRotated, bool storeParityInW)\n"
    "    void Mesh.build_tangent_vectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index, bool splitMirrored, bool splitRotated)\n"
    "    void Mesh.build_tangent_vectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index, bool splitMirrored)\n"
    "    void Mesh.build_tangent_vectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index)\n"
    "    void Mesh.build_tangent_vectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet)\n"
    "    void Mesh.build_tangent_vectors(Ogre::VertexElementSemantic targetSemantic)\n"
    "    void Mesh.build_tangent_vectors()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.suggest_tangent_vector_build_params

  call-seq:
    suggest_tangent_vector_build_params(VertexElementSemantic targetSemantic, unsigned short outSourceCoordSet, 
    unsigned short outIndex) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_suggest_tangent_vector_build_params(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);
  {
    try {
      result = (bool)(*arg1)->suggestTangentVectorBuildParams(arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.build_edge_list

  call-seq:
    build_edge_list

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_build_edge_list(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);
  {
    try {
      (*arg1)->buildEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.free_edge_list

  call-seq:
    free_edge_list

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_free_edge_list(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);
  {
    try {
      (*arg1)->freeEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.prepare_for_shadow_volume

  call-seq:
    prepare_for_shadow_volume

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_prepare_for_shadow_volume(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);
  {
    try {
      (*arg1)->prepareForShadowVolume();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_edge_list

  call-seq:
    get_edge_list(unsigned short lodIndex=0) -> EdgeData
    get_edge_list -> EdgeData
    get_edge_list(unsigned short lodIndex=0) -> EdgeData
    get_edge_list -> EdgeData

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_edge_list__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);
  {
    try {
      result = (Ogre::EdgeData *)(*arg1)->getEdgeList(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_edge_list__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);
  {
    try {
      result = (Ogre::EdgeData *)(*arg1)->getEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_edge_list__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);
  {
    try {
      result = (Ogre::EdgeData *)(*arg1)->getEdgeList(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_edge_list__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);
  {
    try {
      result = (Ogre::EdgeData *)(*arg1)->getEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_get_edge_list(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_get_edge_list__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_get_edge_list__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_get_edge_list__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_get_edge_list__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.get_edge_list", 
    "    Ogre::EdgeData const * Mesh.get_edge_list(unsigned short lodIndex)\n"
    "    Ogre::EdgeData const * Mesh.get_edge_list()\n"
    "    Ogre::EdgeData const * Mesh.get_edge_list(unsigned short lodIndex)\n"
    "    Ogre::EdgeData const * Mesh.get_edge_list()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.is_prepared_for_shadow_volumes

  call-seq:
    is_prepared_for_shadow_volumes -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_is_prepared_for_shadow_volumes(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);
  {
    try {
      result = (bool)(*arg1)->isPreparedForShadowVolumes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.is_edge_list_built

  call-seq:
    is_edge_list_built -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_is_edge_list_built(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);
  {
    try {
      result = (bool)(*arg1)->isEdgeListBuilt();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.prepare_matrices_for_vertex_blend

  call-seq:
    prepare_matrices_for_vertex_blend(Matrix4 blendMatrices, Matrix4 boneMatrices, IndexMap indexMap)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_prepare_matrices_for_vertex_blend(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);
  {
    try {
      (*arg1)->prepareMatricesForVertexBlend((Ogre::Matrix4 const **)arg2,(Ogre::Matrix4 const *)arg3,(Ogre::Mesh::IndexMap const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.software_vertex_blend

  call-seq:
    software_vertex_blend(VertexData sourceVertexData, VertexData targetVertexData, 
    Matrix4 blendMatrices, size_t numMatrices, 
    bool blendNormals)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_software_vertex_blend(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);
  {
    try {
      (*arg1)->softwareVertexBlend((Ogre::VertexData const *)arg2,(Ogre::VertexData const *)arg3,(Ogre::Matrix4 const *const *)arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.software_vertex_morph

  call-seq:
    software_vertex_morph(Real t, HardwareVertexBufferSharedPtr b1, HardwareVertexBufferSharedPtr b2, 
    VertexData targetVertexData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_software_vertex_morph(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);
  {
    try {
      (*arg1)->softwareVertexMorph(arg2,(Ogre::HardwareVertexBufferSharedPtr const &)*arg3,(Ogre::HardwareVertexBufferSharedPtr const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.software_vertex_pose_blend

  call-seq:
    software_vertex_pose_blend(Real weight, Ogre::map<(size_t,Ogre::Vector3,std::less<(size_t)>,Ogre::STLAllocator<(std::pair<(q(const).size_t,Ogre::Vector3)>,Ogre::GeneralAllocPolicy)>)>::type vertexOffsetMap, 
    Ogre::map<(size_t,Ogre::Vector3,std::less<(size_t)>,Ogre::STLAllocator<(std::pair<(q(const).size_t,Ogre::Vector3)>,Ogre::GeneralAllocPolicy)>)>::type normalsMap, 
    VertexData targetVertexData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_software_vertex_pose_blend(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);
  {
    try {
      (*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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_sub_mesh_name_map

  call-seq:
    get_sub_mesh_name_map -> SubMeshNameMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_sub_mesh_name_map(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);
  {
    try {
      result = (Ogre::Mesh::SubMeshNameMap *) &(*arg1)->getSubMeshNameMap();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__tr1__unordered_mapT_Ogre__String_Ogre__ushort_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.set_auto_build_edge_lists

  call-seq:
    set_auto_build_edge_lists(bool autobuild)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_set_auto_build_edge_lists(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);
  {
    try {
      (*arg1)->setAutoBuildEdgeLists(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_auto_build_edge_lists

  call-seq:
    get_auto_build_edge_lists -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_auto_build_edge_lists(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);
  {
    try {
      result = (bool)(*arg1)->getAutoBuildEdgeLists();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_shared_vertex_data_animation_type

  call-seq:
    get_shared_vertex_data_animation_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_shared_vertex_data_animation_type(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);
  {
    try {
      result = (Ogre::VertexAnimationType)(*arg1)->getSharedVertexDataAnimationType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_shared_vertex_data_animation_includes_normals

  call-seq:
    get_shared_vertex_data_animation_includes_normals -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_shared_vertex_data_animation_includes_normals(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);
  {
    try {
      result = (bool)(*arg1)->getSharedVertexDataAnimationIncludesNormals();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.create_animation

  call-seq:
    create_animation(String name, Real length) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_create_animation(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);
  {
    try {
      result = (Ogre::Animation *)(*arg1)->createAnimation((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_animation

  call-seq:
    get_animation(String name) -> Animation
    get_animation(unsigned short index) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_animation__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;
  }
  {
    try {
      result = (Ogre::Animation *)(*arg1)->getAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_animation__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);
  {
    try {
      result = (Ogre::Animation *)(*arg1)->getAnimation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_get_animation(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_get_animation__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_get_animation__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.get_animation", 
    "    Ogre::Animation * Mesh.get_animation(Ogre::String const &name)\n"
    "    Ogre::Animation * Mesh.get_animation(unsigned short index)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._get_animation_impl

  call-seq:
    _get_animation_impl(String name) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__get_animation_impl(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;
  }
  {
    try {
      result = (Ogre::Animation *)(*arg1)->_getAnimationImpl((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.has_animation

  call-seq:
    has_animation(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_has_animation(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;
  }
  {
    try {
      result = (bool)(*arg1)->hasAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.remove_animation

  call-seq:
    remove_animation(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_remove_animation(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;
  }
  {
    try {
      (*arg1)->removeAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_num_animations

  call-seq:
    get_num_animations -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_num_animations(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);
  {
    try {
      result = (unsigned short)(*arg1)->getNumAnimations();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.remove_all_animations

  call-seq:
    remove_all_animations

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_remove_all_animations(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);
  {
    try {
      (*arg1)->removeAllAnimations();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_vertex_data_by_track_handle

  call-seq:
    get_vertex_data_by_track_handle(unsigned short handle) -> VertexData

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_vertex_data_by_track_handle(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);
  {
    try {
      result = (Ogre::VertexData *)(*arg1)->getVertexDataByTrackHandle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.update_material_for_all_sub_meshes

  call-seq:
    update_material_for_all_sub_meshes

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_update_material_for_all_sub_meshes(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);
  {
    try {
      (*arg1)->updateMaterialForAllSubMeshes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._determine_animation_types

  call-seq:
    _determine_animation_types

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__determine_animation_types(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);
  {
    try {
      (*arg1)->_determineAnimationTypes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._get_animation_types_dirty

  call-seq:
    _get_animation_types_dirty -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__get_animation_types_dirty(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);
  {
    try {
      result = (bool)(*arg1)->_getAnimationTypesDirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.create_pose

  call-seq:
    create_pose(ushort target, String name=BLANK) -> Pose
    create_pose(ushort target) -> Pose

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_create_pose__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;
  }
  {
    try {
      result = (Ogre::Pose *)(*arg1)->createPose(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_create_pose__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);
  {
    try {
      result = (Ogre::Pose *)(*arg1)->createPose(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_create_pose(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_create_pose__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_create_pose__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.create_pose", 
    "    Ogre::Pose * Mesh.create_pose(Ogre::ushort target, Ogre::String const &name)\n"
    "    Ogre::Pose * Mesh.create_pose(Ogre::ushort target)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_pose_count

  call-seq:
    get_pose_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_pose_count(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);
  {
    try {
      result = (*arg1)->getPoseCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_pose

  call-seq:
    get_pose(ushort index) -> Pose
    get_pose(String name) -> Pose

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_pose__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);
  {
    try {
      result = (Ogre::Pose *)(*arg1)->getPose(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_pose__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;
  }
  {
    try {
      result = (Ogre::Pose *)(*arg1)->getPose((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_pose(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_get_pose__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_get_pose__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.get_pose", 
    "    Ogre::Pose * Mesh.get_pose(Ogre::ushort index)\n"
    "    Ogre::Pose * Mesh.get_pose(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.remove_pose

  call-seq:
    remove_pose(ushort index)
    remove_pose(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_remove_pose__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);
  {
    try {
      (*arg1)->removePose(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_remove_pose__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;
  }
  {
    try {
      (*arg1)->removePose((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_remove_pose(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_remove_pose__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_remove_pose__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.remove_pose", 
    "    void Mesh.remove_pose(Ogre::ushort index)\n"
    "    void Mesh.remove_pose(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.remove_all_poses

  call-seq:
    remove_all_poses

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_remove_all_poses(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);
  {
    try {
      (*arg1)->removeAllPoses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_pose_list

  call-seq:
    get_pose_list -> PoseList

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_pose_list(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);
  {
    try {
      result = (Ogre::PoseList *) &(*arg1)->getPoseList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_lod_strategy

  call-seq:
    get_lod_strategy -> LodStrategy

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_lod_strategy(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);
  {
    try {
      result = (Ogre::LodStrategy *)(*arg1)->getLodStrategy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.set_lod_strategy

  call-seq:
    set_lod_strategy(LodStrategy lodStrategy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_set_lod_strategy(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);
  {
    try {
      (*arg1)->setLodStrategy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.prepare

  call-seq:
    prepare(bool backgroundThread=false)
    prepare

An instance method.

*/
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);
  {
    try {
      (*arg1)->prepare(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (*arg1)->prepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Resource.load

  call-seq:
    load(bool backgroundThread=false)
    load

An instance method.

*/
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);
  {
    try {
      (*arg1)->load(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (*arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Resource.reload

  call-seq:
    reload

An instance method.

*/
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);
  {
    try {
      (*arg1)->reload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_reloadable

  call-seq:
    is_reloadable -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_is_reloadable(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);
  {
    try {
      result = (bool)(*arg1)->isReloadable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_manually_loaded

  call-seq:
    is_manually_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_is_manually_loaded(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);
  {
    try {
      result = (bool)(*arg1)->isManuallyLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (*arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_size

  call-seq:
    get_size -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_size(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);
  {
    try {
      result = (*arg1)->getSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.touch

  call-seq:
    touch

An instance method.

*/
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);
  {
    try {
      (*arg1)->touch();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_name(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);
  {
    try {
      result = (Ogre::String *) &(*arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_handle

  call-seq:
    get_handle -> ResourceHandle

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_handle(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);
  {
    try {
      result = (Ogre::ResourceHandle)(*arg1)->getHandle();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_prepared

  call-seq:
    is_prepared -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_is_prepared(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);
  {
    try {
      result = (bool)(*arg1)->isPrepared();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_loaded

  call-seq:
    is_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_is_loaded(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);
  {
    try {
      result = (bool)(*arg1)->isLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_loading

  call-seq:
    is_loading -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_is_loading(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);
  {
    try {
      result = (bool)(*arg1)->isLoading();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_loading_state

  call-seq:
    get_loading_state -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_loading_state(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);
  {
    try {
      result = (Ogre::Resource::LoadingState)(*arg1)->getLoadingState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.is_background_loaded

  call-seq:
    is_background_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_is_background_loaded(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);
  {
    try {
      result = (bool)(*arg1)->isBackgroundLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.set_background_loaded

  call-seq:
    set_background_loaded(bool bl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_set_background_loaded(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);
  {
    try {
      (*arg1)->setBackgroundLoaded(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.escalate_loading

  call-seq:
    escalate_loading

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_escalate_loading(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);
  {
    try {
      (*arg1)->escalateLoading();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.add_listener

  call-seq:
    add_listener(Listener lis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_add_listener(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);
  {
    try {
      (*arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.remove_listener

  call-seq:
    remove_listener(Listener lis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_remove_listener(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);
  {
    try {
      (*arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_group

  call-seq:
    get_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_group(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);
  {
    try {
      result = (Ogre::String *) &(*arg1)->getGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.change_group_ownership

  call-seq:
    change_group_ownership(String newGroup)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_change_group_ownership(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;
  }
  {
    try {
      (*arg1)->changeGroupOwnership((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_creator

  call-seq:
    get_creator -> ResourceManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_creator(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);
  {
    try {
      result = (Ogre::ResourceManager *)(*arg1)->getCreator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_origin

  call-seq:
    get_origin -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_origin(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);
  {
    try {
      result = (Ogre::String *) &(*arg1)->getOrigin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._notify_origin

  call-seq:
    _notify_origin(String origin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__notify_origin(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;
  }
  {
    try {
      (*arg1)->_notifyOrigin((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Resource.get_state_count

  call-seq:
    get_state_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_state_count(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);
  {
    try {
      result = (*arg1)->getStateCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._dirty_state

  call-seq:
    _dirty_state

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__dirty_state(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);
  {
    try {
      (*arg1)->_dirtyState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._fire_loading_complete

  call-seq:
    _fire_loading_complete(bool wasBackgroundLoaded)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__fire_loading_complete(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);
  {
    try {
      (*arg1)->_fireLoadingComplete(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._fire_preparing_complete

  call-seq:
    _fire_preparing_complete(bool wasBackgroundLoaded)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__fire_preparing_complete(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);
  {
    try {
      (*arg1)->_firePreparingComplete(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Resource._fire_unloading_complete

  call-seq:
    _fire_unloading_complete

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr__fire_unloading_complete(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);
  {
    try {
      (*arg1)->_fireUnloadingComplete();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.get_param_dictionary

  call-seq:
    get_param_dictionary -> ParamDictionary
    get_param_dictionary -> ParamDictionary

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_param_dictionary__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);
  {
    try {
      result = (Ogre::ParamDictionary *)(*arg1)->getParamDictionary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_param_dictionary__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);
  {
    try {
      result = (Ogre::ParamDictionary *)(*arg1)->getParamDictionary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_get_param_dictionary(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_get_param_dictionary__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_get_param_dictionary__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringInterface.get_param_dictionary", 
    "    Ogre::ParamDictionary const * StringInterface.get_param_dictionary()\n"
    "    Ogre::ParamDictionary const * StringInterface.get_param_dictionary()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.get_parameters

  call-seq:
    get_parameters -> ParameterList

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_parameters(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);
  {
    try {
      result = (Ogre::ParameterList *) &(*arg1)->getParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.set_parameter

  call-seq:
    set_parameter(String name, String value) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_set_parameter(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;
  }
  {
    try {
      result = (bool)(*arg1)->setParameter((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringInterface.set_parameter_list

  call-seq:
    set_parameter_list(NameValuePairList paramList)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_set_parameter_list(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);
  {
    try {
      (*arg1)->setParameterList((Ogre::NameValuePairList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.get_parameter

  call-seq:
    get_parameter(String name) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_get_parameter(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;
  }
  {
    try {
      result = (*arg1)->getParameter((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringInterface.copy_parameters_to

  call-seq:
    copy_parameters_to(StringInterface dest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_copy_parameters_to(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);
  {
    try {
      (*arg1)->copyParametersTo(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StringInterface.cleanup_dictionary

  call-seq:
    cleanup_dictionary

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_cleanup_dictionary(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);
  {
    try {
      (*arg1)->cleanupDictionary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Mesh < Ogre::Ogre::Resource, Ogre::Ogre::AnimationContainer

  Proxy of C++ Ogre::Mesh class


*/
swig_class SwigClassMesh;


/*
  Document-method: Ogre::Mesh.new

  call-seq:
    Mesh.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual=false, 
    ManualResourceLoader loader=0)
    Mesh.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual=false)
    Mesh.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Mesh *)new Ogre::Mesh(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Mesh *)new Ogre::Mesh(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Mesh *)new Ogre::Mesh(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::Mesh.create_sub_mesh

  call-seq:
    create_sub_mesh -> SubMesh
    create_sub_mesh(String name) -> SubMesh

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_create_sub_mesh__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);
  {
    try {
      result = (Ogre::SubMesh *)(arg1)->createSubMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_create_sub_mesh__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;
  }
  {
    try {
      result = (Ogre::SubMesh *)(arg1)->createSubMesh((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_sub_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Mesh_create_sub_mesh__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_create_sub_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.create_sub_mesh", 
    "    Ogre::SubMesh * Mesh.create_sub_mesh()\n"
    "    Ogre::SubMesh * Mesh.create_sub_mesh(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.name_sub_mesh

  call-seq:
    name_sub_mesh(String name, ushort index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_name_sub_mesh(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);
  {
    try {
      (arg1)->nameSubMesh((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.unname_sub_mesh

  call-seq:
    unname_sub_mesh(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_unname_sub_mesh(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;
  }
  {
    try {
      (arg1)->unnameSubMesh((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._get_sub_mesh_index

  call-seq:
    _get_sub_mesh_index(String name) -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__get_sub_mesh_index(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;
  }
  {
    try {
      result = (Ogre::ushort)((Ogre::Mesh const *)arg1)->_getSubMeshIndex((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::Mesh.get_num_sub_meshes

  call-seq:
    get_num_sub_meshes -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_num_sub_meshes(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);
  {
    try {
      result = (unsigned short)((Ogre::Mesh const *)arg1)->getNumSubMeshes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_sub_mesh

  call-seq:
    get_sub_mesh(unsigned short index) -> SubMesh
    get_sub_mesh(String name) -> SubMesh

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_sub_mesh__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);
  {
    try {
      result = (Ogre::SubMesh *)((Ogre::Mesh const *)arg1)->getSubMesh(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_get_sub_mesh__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;
  }
  {
    try {
      result = (Ogre::SubMesh *)((Ogre::Mesh const *)arg1)->getSubMesh((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_sub_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 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_get_sub_mesh__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_get_sub_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.get_sub_mesh", 
    "    Ogre::SubMesh * Mesh.get_sub_mesh(unsigned short index)\n"
    "    Ogre::SubMesh * Mesh.get_sub_mesh(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.destroy_sub_mesh

  call-seq:
    destroy_sub_mesh(unsigned short index)
    destroy_sub_mesh(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_destroy_sub_mesh__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);
  {
    try {
      (arg1)->destroySubMesh(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_destroy_sub_mesh__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;
  }
  {
    try {
      (arg1)->destroySubMesh((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_destroy_sub_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 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_destroy_sub_mesh__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_destroy_sub_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.destroy_sub_mesh", 
    "    void Mesh.destroy_sub_mesh(unsigned short index)\n"
    "    void Mesh.destroy_sub_mesh(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_sub_mesh_iterator

  call-seq:
    get_sub_mesh_iterator -> SubMeshIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_sub_mesh_iterator(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);
  {
    try {
      result = (arg1)->getSubMeshIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Mesh.sharedVertexData

  call-seq:
    sharedVertexData -> VertexData

Get value of attribute.

*/

/*
  Document-method: Ogre::Mesh.sharedVertexData=

  call-seq:
    sharedVertexData=(x) -> VertexData

Set new value for attribute.

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



/*
  Document-method: Ogre::Mesh.sharedBlendIndexToBoneIndexMap

  call-seq:
    sharedBlendIndexToBoneIndexMap -> IndexMap

Get value of attribute.

*/

/*
  Document-method: Ogre::Mesh.sharedBlendIndexToBoneIndexMap=

  call-seq:
    sharedBlendIndexToBoneIndexMap=(x) -> IndexMap

Set new value for attribute.

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



/*
  Document-method: Ogre::Mesh.clone

  call-seq:
    clone(newName, newGroup=BLANK) -> MeshPtr
    clone(newName) -> MeshPtr

Create a duplicate of the class.
*/
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;
  }
  {
    try {
      result = (arg1)->clone((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      result = (arg1)->clone((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Mesh.get_bounds

  call-seq:
    get_bounds -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_bounds(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::Mesh const *)arg1)->getBounds();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_bounding_sphere_radius

  call-seq:
    get_bounding_sphere_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_bounding_sphere_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Mesh const *)arg1)->getBoundingSphereRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._set_bounds

  call-seq:
    _set_bounds(AxisAlignedBox bounds, bool pad=true)
    _set_bounds(AxisAlignedBox bounds)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__set_bounds__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);
  {
    try {
      (arg1)->_setBounds((Ogre::AxisAlignedBox const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__set_bounds__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);
  {
    try {
      (arg1)->_setBounds((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh__set_bounds(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__set_bounds__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__set_bounds__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh._set_bounds", 
    "    void Mesh._set_bounds(Ogre::AxisAlignedBox const &bounds, bool pad)\n"
    "    void Mesh._set_bounds(Ogre::AxisAlignedBox const &bounds)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._set_bounding_sphere_radius

  call-seq:
    _set_bounding_sphere_radius(Real radius)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__set_bounding_sphere_radius(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);
  {
    try {
      (arg1)->_setBoundingSphereRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.set_skeleton_name

  call-seq:
    set_skeleton_name(String skelName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_set_skeleton_name(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;
  }
  {
    try {
      (arg1)->setSkeletonName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.has_skeleton

  call-seq:
    has_skeleton -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_has_skeleton(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);
  {
    try {
      result = (bool)((Ogre::Mesh const *)arg1)->hasSkeleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.has_vertex_animation

  call-seq:
    has_vertex_animation -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_has_vertex_animation(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);
  {
    try {
      result = (bool)((Ogre::Mesh const *)arg1)->hasVertexAnimation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_skeleton

  call-seq:
    get_skeleton -> SkeletonPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_skeleton(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);
  {
    try {
      result = (Ogre::SkeletonPtr *) &((Ogre::Mesh const *)arg1)->getSkeleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_skeleton_name

  call-seq:
    get_skeleton_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_skeleton_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Mesh const *)arg1)->getSkeletonName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._init_animation_state

  call-seq:
    _init_animation_state(AnimationStateSet animSet)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__init_animation_state(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);
  {
    try {
      (arg1)->_initAnimationState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._refresh_animation_state

  call-seq:
    _refresh_animation_state(AnimationStateSet animSet)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__refresh_animation_state(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);
  {
    try {
      (arg1)->_refreshAnimationState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.add_bone_assignment

  call-seq:
    add_bone_assignment(VertexBoneAssignment vertBoneAssign)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_add_bone_assignment(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);
  {
    try {
      (arg1)->addBoneAssignment((Ogre::VertexBoneAssignment const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.clear_bone_assignments

  call-seq:
    clear_bone_assignments

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_clear_bone_assignments(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);
  {
    try {
      (arg1)->clearBoneAssignments();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._notify_skeleton

  call-seq:
    _notify_skeleton(SkeletonPtr pSkel)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__notify_skeleton(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);
  {
    try {
      (arg1)->_notifySkeleton(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_bone_assignment_iterator

  call-seq:
    get_bone_assignment_iterator -> BoneAssignmentIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_bone_assignment_iterator(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);
  {
    try {
      result = (arg1)->getBoneAssignmentIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Mesh.get_bone_assignments

  call-seq:
    get_bone_assignments -> VertexBoneAssignmentList

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_bone_assignments(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);
  {
    try {
      result = (Ogre::Mesh::VertexBoneAssignmentList *) &((Ogre::Mesh const *)arg1)->getBoneAssignments();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::Mesh.get_num_lod_levels

  call-seq:
    get_num_lod_levels -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_num_lod_levels(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::Mesh const *)arg1)->getNumLodLevels();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_lod_level

  call-seq:
    get_lod_level(ushort index) -> MeshLodUsage

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_lod_level(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);
  {
    try {
      result = (Ogre::MeshLodUsage *) &((Ogre::Mesh const *)arg1)->getLodLevel(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshLodUsage, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.create_manual_lod_level

  call-seq:
    create_manual_lod_level(Real value, String meshName, String groupName=Ogre::String())
    create_manual_lod_level(Real value, String meshName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_create_manual_lod_level__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;
  }
  {
    try {
      (arg1)->createManualLodLevel(arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_create_manual_lod_level__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;
  }
  {
    try {
      (arg1)->createManualLodLevel(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_create_manual_lod_level(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_create_manual_lod_level__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_create_manual_lod_level__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Mesh.create_manual_lod_level", 
    "    void Mesh.create_manual_lod_level(Ogre::Real value, Ogre::String const &meshName, Ogre::String const &groupName)\n"
    "    void Mesh.create_manual_lod_level(Ogre::Real value, Ogre::String const &meshName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.update_manual_lod_level

  call-seq:
    update_manual_lod_level(ushort index, String meshName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_update_manual_lod_level(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;
  }
  {
    try {
      (arg1)->updateManualLodLevel(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_lod_index

  call-seq:
    get_lod_index(Real value) -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_lod_index(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::Mesh const *)arg1)->getLodIndex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.is_lod_manual

  call-seq:
    is_lod_manual -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_is_lod_manual(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);
  {
    try {
      result = (bool)((Ogre::Mesh const *)arg1)->isLodManual();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._set_lod_info

  call-seq:
    _set_lod_info(unsigned short numLevels, bool isManual)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__set_lod_info(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);
  {
    try {
      (arg1)->_setLodInfo(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._set_lod_usage

  call-seq:
    _set_lod_usage(unsigned short level, MeshLodUsage usage)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__set_lod_usage(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);
  {
    try {
      (arg1)->_setLodUsage(arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._set_sub_mesh_lod_face_list

  call-seq:
    _set_sub_mesh_lod_face_list(unsigned short subIdx, unsigned short level, IndexData facedata)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__set_sub_mesh_lod_face_list(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);
  {
    try {
      (arg1)->_setSubMeshLodFaceList(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.remove_lod_levels

  call-seq:
    remove_lod_levels

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_remove_lod_levels(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);
  {
    try {
      (arg1)->removeLodLevels();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.set_vertex_buffer_policy

  call-seq:
    set_vertex_buffer_policy(Usage usage, bool shadowBuffer=false)
    set_vertex_buffer_policy(Usage usage)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_set_vertex_buffer_policy__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);
  {
    try {
      (arg1)->setVertexBufferPolicy(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_set_vertex_buffer_policy__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);
  {
    try {
      (arg1)->setVertexBufferPolicy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_set_vertex_buffer_policy(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_set_vertex_buffer_policy__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_set_vertex_buffer_policy__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.set_vertex_buffer_policy", 
    "    void Mesh.set_vertex_buffer_policy(Ogre::HardwareBuffer::Usage usage, bool shadowBuffer)\n"
    "    void Mesh.set_vertex_buffer_policy(Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.set_index_buffer_policy

  call-seq:
    set_index_buffer_policy(Usage usage, bool shadowBuffer=false)
    set_index_buffer_policy(Usage usage)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_set_index_buffer_policy__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);
  {
    try {
      (arg1)->setIndexBufferPolicy(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_set_index_buffer_policy__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);
  {
    try {
      (arg1)->setIndexBufferPolicy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_set_index_buffer_policy(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_set_index_buffer_policy__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_set_index_buffer_policy__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.set_index_buffer_policy", 
    "    void Mesh.set_index_buffer_policy(Ogre::HardwareBuffer::Usage usage, bool shadowBuffer)\n"
    "    void Mesh.set_index_buffer_policy(Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_vertex_buffer_usage

  call-seq:
    get_vertex_buffer_usage -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_vertex_buffer_usage(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);
  {
    try {
      result = (Ogre::HardwareBuffer::Usage)((Ogre::Mesh const *)arg1)->getVertexBufferUsage();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_index_buffer_usage

  call-seq:
    get_index_buffer_usage -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_index_buffer_usage(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);
  {
    try {
      result = (Ogre::HardwareBuffer::Usage)((Ogre::Mesh const *)arg1)->getIndexBufferUsage();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.is_vertex_buffer_shadowed

  call-seq:
    is_vertex_buffer_shadowed -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_is_vertex_buffer_shadowed(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);
  {
    try {
      result = (bool)((Ogre::Mesh const *)arg1)->isVertexBufferShadowed();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.is_index_buffer_shadowed

  call-seq:
    is_index_buffer_shadowed -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_is_index_buffer_shadowed(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);
  {
    try {
      result = (bool)((Ogre::Mesh const *)arg1)->isIndexBufferShadowed();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._rationalise_bone_assignments

  call-seq:
    _rationalise_bone_assignments(size_t vertexCount, VertexBoneAssignmentList assignments) -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__rationalise_bone_assignments(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);
  {
    try {
      result = (unsigned short)(arg1)->_rationaliseBoneAssignments(arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._compile_bone_assignments

  call-seq:
    _compile_bone_assignments

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__compile_bone_assignments(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);
  {
    try {
      (arg1)->_compileBoneAssignments();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._update_compiled_bone_assignments

  call-seq:
    _update_compiled_bone_assignments

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__update_compiled_bone_assignments(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);
  {
    try {
      (arg1)->_updateCompiledBoneAssignments();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.build_tangent_vectors

  call-seq:
    build_tangent_vectors(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0, 
    unsigned short index=0, 
    bool splitMirrored=false, bool splitRotated=false, 
    bool storeParityInW=false)
    build_tangent_vectors(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0, 
    unsigned short index=0, 
    bool splitMirrored=false, bool splitRotated=false)
    build_tangent_vectors(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0, 
    unsigned short index=0, 
    bool splitMirrored=false)
    build_tangent_vectors(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0, 
    unsigned short index=0)
    build_tangent_vectors(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0)
    build_tangent_vectors(VertexElementSemantic targetSemantic=VES_TANGENT)
    build_tangent_vectors

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_build_tangent_vectors__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);
  {
    try {
      (arg1)->buildTangentVectors(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_build_tangent_vectors__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);
  {
    try {
      (arg1)->buildTangentVectors(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_build_tangent_vectors__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);
  {
    try {
      (arg1)->buildTangentVectors(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_build_tangent_vectors__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);
  {
    try {
      (arg1)->buildTangentVectors(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_build_tangent_vectors__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);
  {
    try {
      (arg1)->buildTangentVectors(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_build_tangent_vectors__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);
  {
    try {
      (arg1)->buildTangentVectors(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_build_tangent_vectors__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);
  {
    try {
      (arg1)->buildTangentVectors();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_build_tangent_vectors(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_build_tangent_vectors__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_build_tangent_vectors__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_build_tangent_vectors__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_build_tangent_vectors__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_build_tangent_vectors__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_build_tangent_vectors__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_build_tangent_vectors__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Mesh.build_tangent_vectors", 
    "    void Mesh.build_tangent_vectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index, bool splitMirrored, bool splitRotated, bool storeParityInW)\n"
    "    void Mesh.build_tangent_vectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index, bool splitMirrored, bool splitRotated)\n"
    "    void Mesh.build_tangent_vectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index, bool splitMirrored)\n"
    "    void Mesh.build_tangent_vectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index)\n"
    "    void Mesh.build_tangent_vectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet)\n"
    "    void Mesh.build_tangent_vectors(Ogre::VertexElementSemantic targetSemantic)\n"
    "    void Mesh.build_tangent_vectors()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.suggest_tangent_vector_build_params

  call-seq:
    suggest_tangent_vector_build_params(VertexElementSemantic targetSemantic, unsigned short outSourceCoordSet, 
    unsigned short outIndex) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_suggest_tangent_vector_build_params(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);
  {
    try {
      result = (bool)(arg1)->suggestTangentVectorBuildParams(arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.build_edge_list

  call-seq:
    build_edge_list

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_build_edge_list(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);
  {
    try {
      (arg1)->buildEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.free_edge_list

  call-seq:
    free_edge_list

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_free_edge_list(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);
  {
    try {
      (arg1)->freeEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.prepare_for_shadow_volume

  call-seq:
    prepare_for_shadow_volume

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_prepare_for_shadow_volume(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);
  {
    try {
      (arg1)->prepareForShadowVolume();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_edge_list

  call-seq:
    get_edge_list(unsigned short lodIndex=0) -> EdgeData
    get_edge_list -> EdgeData
    get_edge_list(unsigned short lodIndex=0) -> EdgeData
    get_edge_list -> EdgeData

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_edge_list__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);
  {
    try {
      result = (Ogre::EdgeData *)(arg1)->getEdgeList(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_get_edge_list__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);
  {
    try {
      result = (Ogre::EdgeData *)(arg1)->getEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_get_edge_list__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);
  {
    try {
      result = (Ogre::EdgeData *)((Ogre::Mesh const *)arg1)->getEdgeList(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_get_edge_list__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);
  {
    try {
      result = (Ogre::EdgeData *)((Ogre::Mesh const *)arg1)->getEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_get_edge_list(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_get_edge_list__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_get_edge_list__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_get_edge_list__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_get_edge_list__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.get_edge_list", 
    "    Ogre::EdgeData const * Mesh.get_edge_list(unsigned short lodIndex)\n"
    "    Ogre::EdgeData const * Mesh.get_edge_list()\n"
    "    Ogre::EdgeData const * Mesh.get_edge_list(unsigned short lodIndex)\n"
    "    Ogre::EdgeData const * Mesh.get_edge_list()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.is_prepared_for_shadow_volumes

  call-seq:
    is_prepared_for_shadow_volumes -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_is_prepared_for_shadow_volumes(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);
  {
    try {
      result = (bool)((Ogre::Mesh const *)arg1)->isPreparedForShadowVolumes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.is_edge_list_built

  call-seq:
    is_edge_list_built -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_is_edge_list_built(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);
  {
    try {
      result = (bool)((Ogre::Mesh const *)arg1)->isEdgeListBuilt();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.prepare_matrices_for_vertex_blend

  call-seq:
    prepare_matrices_for_vertex_blend(Matrix4 blendMatrices, Matrix4 boneMatrices, IndexMap indexMap)

A class method.

*/
SWIGINTERN VALUE
_wrap_Mesh_prepare_matrices_for_vertex_blend(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);
  {
    try {
      Ogre::Mesh::prepareMatricesForVertexBlend((Ogre::Matrix4 const **)arg1,(Ogre::Matrix4 const *)arg2,(Ogre::vector< unsigned short,Ogre::STLAllocator< unsigned short,Ogre::GeneralAllocPolicy > >::type const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.software_vertex_blend

  call-seq:
    software_vertex_blend(VertexData sourceVertexData, VertexData targetVertexData, 
    Matrix4 blendMatrices, size_t numMatrices, 
    bool blendNormals)

A class method.

*/
SWIGINTERN VALUE
_wrap_Mesh_software_vertex_blend(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);
  {
    try {
      Ogre::Mesh::softwareVertexBlend((Ogre::VertexData const *)arg1,(Ogre::VertexData const *)arg2,(Ogre::Matrix4 const *const *)arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.software_vertex_morph

  call-seq:
    software_vertex_morph(Real t, HardwareVertexBufferSharedPtr b1, HardwareVertexBufferSharedPtr b2, 
    VertexData targetVertexData)

A class method.

*/
SWIGINTERN VALUE
_wrap_Mesh_software_vertex_morph(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);
  {
    try {
      Ogre::Mesh::softwareVertexMorph(arg1,(Ogre::HardwareVertexBufferSharedPtr const &)*arg2,(Ogre::HardwareVertexBufferSharedPtr const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.software_vertex_pose_blend

  call-seq:
    software_vertex_pose_blend(Real weight, Ogre::map<(size_t,Ogre::Vector3,std::less<(size_t)>,Ogre::STLAllocator<(std::pair<(q(const).size_t,Ogre::Vector3)>,Ogre::GeneralAllocPolicy)>)>::type vertexOffsetMap, 
    Ogre::map<(size_t,Ogre::Vector3,std::less<(size_t)>,Ogre::STLAllocator<(std::pair<(q(const).size_t,Ogre::Vector3)>,Ogre::GeneralAllocPolicy)>)>::type normalsMap, 
    VertexData targetVertexData)

A class method.

*/
SWIGINTERN VALUE
_wrap_Mesh_software_vertex_pose_blend(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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_sub_mesh_name_map

  call-seq:
    get_sub_mesh_name_map -> SubMeshNameMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_sub_mesh_name_map(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);
  {
    try {
      result = (Ogre::Mesh::SubMeshNameMap *) &((Ogre::Mesh const *)arg1)->getSubMeshNameMap();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__tr1__unordered_mapT_Ogre__String_Ogre__ushort_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.set_auto_build_edge_lists

  call-seq:
    set_auto_build_edge_lists(bool autobuild)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_set_auto_build_edge_lists(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);
  {
    try {
      (arg1)->setAutoBuildEdgeLists(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_auto_build_edge_lists

  call-seq:
    get_auto_build_edge_lists -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_auto_build_edge_lists(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);
  {
    try {
      result = (bool)((Ogre::Mesh const *)arg1)->getAutoBuildEdgeLists();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_shared_vertex_data_animation_type

  call-seq:
    get_shared_vertex_data_animation_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_shared_vertex_data_animation_type(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);
  {
    try {
      result = (Ogre::VertexAnimationType)((Ogre::Mesh const *)arg1)->getSharedVertexDataAnimationType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_shared_vertex_data_animation_includes_normals

  call-seq:
    get_shared_vertex_data_animation_includes_normals -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_shared_vertex_data_animation_includes_normals(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);
  {
    try {
      result = (bool)((Ogre::Mesh const *)arg1)->getSharedVertexDataAnimationIncludesNormals();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.create_animation

  call-seq:
    create_animation(String name, Real length) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_create_animation(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);
  {
    try {
      result = (Ogre::Animation *)(arg1)->createAnimation((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_animation

  call-seq:
    get_animation(String name) -> Animation
    get_animation(unsigned short index) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_animation__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;
  }
  {
    try {
      result = (Ogre::Animation *)((Ogre::Mesh const *)arg1)->getAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._get_animation_impl

  call-seq:
    _get_animation_impl(String name) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__get_animation_impl(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;
  }
  {
    try {
      result = (Ogre::Animation *)((Ogre::Mesh const *)arg1)->_getAnimationImpl((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.has_animation

  call-seq:
    has_animation(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_has_animation(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;
  }
  {
    try {
      result = (bool)((Ogre::Mesh const *)arg1)->hasAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.remove_animation

  call-seq:
    remove_animation(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_remove_animation(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;
  }
  {
    try {
      (arg1)->removeAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_num_animations

  call-seq:
    get_num_animations -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_num_animations(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);
  {
    try {
      result = (unsigned short)((Ogre::Mesh const *)arg1)->getNumAnimations();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_animation

  call-seq:
    get_animation(String name) -> Animation
    get_animation(unsigned short index) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_animation__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);
  {
    try {
      result = (Ogre::Animation *)((Ogre::Mesh const *)arg1)->getAnimation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_get_animation(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_get_animation__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_get_animation__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.get_animation", 
    "    Ogre::Animation * Mesh.get_animation(Ogre::String const &name)\n"
    "    Ogre::Animation * Mesh.get_animation(unsigned short index)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.remove_all_animations

  call-seq:
    remove_all_animations

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_remove_all_animations(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);
  {
    try {
      (arg1)->removeAllAnimations();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_vertex_data_by_track_handle

  call-seq:
    get_vertex_data_by_track_handle(unsigned short handle) -> VertexData

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_vertex_data_by_track_handle(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);
  {
    try {
      result = (Ogre::VertexData *)(arg1)->getVertexDataByTrackHandle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.update_material_for_all_sub_meshes

  call-seq:
    update_material_for_all_sub_meshes

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_update_material_for_all_sub_meshes(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);
  {
    try {
      (arg1)->updateMaterialForAllSubMeshes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._determine_animation_types

  call-seq:
    _determine_animation_types

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__determine_animation_types(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);
  {
    try {
      ((Ogre::Mesh const *)arg1)->_determineAnimationTypes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh._get_animation_types_dirty

  call-seq:
    _get_animation_types_dirty -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh__get_animation_types_dirty(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);
  {
    try {
      result = (bool)((Ogre::Mesh const *)arg1)->_getAnimationTypesDirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.create_pose

  call-seq:
    create_pose(ushort target, String name=BLANK) -> Pose
    create_pose(ushort target) -> Pose

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_create_pose__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;
  }
  {
    try {
      result = (Ogre::Pose *)(arg1)->createPose(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_create_pose__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);
  {
    try {
      result = (Ogre::Pose *)(arg1)->createPose(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_create_pose(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_create_pose__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_create_pose__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.create_pose", 
    "    Ogre::Pose * Mesh.create_pose(Ogre::ushort target, Ogre::String const &name)\n"
    "    Ogre::Pose * Mesh.create_pose(Ogre::ushort target)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_pose_count

  call-seq:
    get_pose_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_pose_count(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);
  {
    try {
      result = ((Ogre::Mesh const *)arg1)->getPoseCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_pose

  call-seq:
    get_pose(ushort index) -> Pose
    get_pose(String name) -> Pose

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_pose__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);
  {
    try {
      result = (Ogre::Pose *)(arg1)->getPose(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_get_pose__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;
  }
  {
    try {
      result = (Ogre::Pose *)(arg1)->getPose((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_pose(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_get_pose__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_get_pose__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.get_pose", 
    "    Ogre::Pose * Mesh.get_pose(Ogre::ushort index)\n"
    "    Ogre::Pose * Mesh.get_pose(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.remove_pose

  call-seq:
    remove_pose(ushort index)
    remove_pose(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_remove_pose__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);
  {
    try {
      (arg1)->removePose(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_remove_pose__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;
  }
  {
    try {
      (arg1)->removePose((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_remove_pose(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_remove_pose__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_remove_pose__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.remove_pose", 
    "    void Mesh.remove_pose(Ogre::ushort index)\n"
    "    void Mesh.remove_pose(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.remove_all_poses

  call-seq:
    remove_all_poses

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_remove_all_poses(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);
  {
    try {
      (arg1)->removeAllPoses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_pose_list

  call-seq:
    get_pose_list -> PoseList

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_pose_list(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);
  {
    try {
      result = (Ogre::PoseList *) &((Ogre::Mesh const *)arg1)->getPoseList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.get_lod_strategy

  call-seq:
    get_lod_strategy -> LodStrategy

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_get_lod_strategy(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);
  {
    try {
      result = (Ogre::LodStrategy *)((Ogre::Mesh const *)arg1)->getLodStrategy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.set_lod_strategy

  call-seq:
    set_lod_strategy(LodStrategy lodStrategy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Mesh_set_lod_strategy(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);
  {
    try {
      (arg1)->setLodStrategy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::MeshPtr < Ogre::Ogre::MeshSharedPtr

  Proxy of C++ Ogre::MeshPtr class


*/
swig_class SwigClassMeshPtr;


/*
  Document-method: Ogre::MeshPtr.new

  call-seq:
    MeshPtr.new
    MeshPtr.new(Mesh rep)
    MeshPtr.new(MeshPtr r)
    MeshPtr.new(ResourcePtr r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::MeshPtr *)new Ogre::MeshPtr();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MeshPtr *)new Ogre::MeshPtr(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::MeshPtr *)new Ogre::MeshPtr((Ogre::MeshPtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::MeshPtr *)new Ogre::MeshPtr((Ogre::ResourcePtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::MeshLodUsage

  Proxy of C++ Ogre::MeshLodUsage class


*/
swig_class SwigClassMeshLodUsage;


/*
  Document-method: Ogre::MeshLodUsage.userValue

  call-seq:
    userValue -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::MeshLodUsage.userValue=

  call-seq:
    userValue=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::MeshLodUsage.value

  call-seq:
    value -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::MeshLodUsage.value=

  call-seq:
    value=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::MeshLodUsage.manualName

  call-seq:
    manualName -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::MeshLodUsage.manualName=

  call-seq:
    manualName=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::MeshLodUsage.manualGroup

  call-seq:
    manualGroup -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::MeshLodUsage.manualGroup=

  call-seq:
    manualGroup=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::MeshLodUsage.manualMesh

  call-seq:
    manualMesh -> MeshPtr

Get value of attribute.

*/

/*
  Document-method: Ogre::MeshLodUsage.manualMesh=

  call-seq:
    manualMesh=(x) -> MeshPtr

Set new value for attribute.

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



/*
  Document-method: Ogre::MeshLodUsage.edgeData

  call-seq:
    edgeData -> EdgeData

Get value of attribute.

*/

/*
  Document-method: Ogre::MeshLodUsage.edgeData=

  call-seq:
    edgeData=(x) -> EdgeData

Set new value for attribute.

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


/*
  Document-method: Ogre::MeshLodUsage.new

  call-seq:
    MeshLodUsage.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::MeshLodUsage *)new Ogre::MeshLodUsage();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MeshLodUsage(Ogre::MeshLodUsage *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::Node

  Proxy of C++ Ogre::Node class


*/
swig_class SwigClassNode;


/*
  Document-method: Ogre::TransformSpace.TS_LOCAL

  call-seq:
    TS_LOCAL -> int

A class method.

*/

/*
  Document-method: Ogre::TransformSpace.TS_PARENT

  call-seq:
    TS_PARENT -> int

A class method.

*/

/*
  Document-method: Ogre::TransformSpace.TS_WORLD

  call-seq:
    TS_WORLD -> int

A class method.

*/
SWIGINTERN void
free_Ogre_Node(Ogre::Node *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Node.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Node const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_parent

  call-seq:
    get_parent -> Node

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_parent(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);
  {
    try {
      result = (Ogre::Node *)((Ogre::Node const *)arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_orientation

  call-seq:
    get_orientation -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_orientation(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);
  {
    try {
      result = (Ogre::Quaternion *) &((Ogre::Node const *)arg1)->getOrientation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.set_orientation

  call-seq:
    set_orientation(Quaternion q)
    set_orientation(Real w, Real x, Real y, Real z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_set_orientation__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);
  {
    try {
      (arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_set_orientation__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);
  {
    try {
      (arg1)->setOrientation(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_set_orientation(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_set_orientation__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_set_orientation__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Node.set_orientation", 
    "    void Node.set_orientation(Ogre::Quaternion const &q)\n"
    "    void Node.set_orientation(Ogre::Real w, Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Node.reset_orientation

  call-seq:
    reset_orientation

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_reset_orientation(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);
  {
    try {
      (arg1)->resetOrientation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.set_position

  call-seq:
    set_position(Vector3 pos)
    set_position(Real x, Real y, Real z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_set_position__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);
  {
    try {
      (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_set_position__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);
  {
    try {
      (arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_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_set_position__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_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Node.set_position", 
    "    void Node.set_position(Ogre::Vector3 const &pos)\n"
    "    void Node.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_position

  call-seq:
    get_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Node const *)arg1)->getPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.set_scale

  call-seq:
    set_scale(Vector3 scale)
    set_scale(Real x, Real y, Real z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_set_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 *","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);
  {
    try {
      (arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_set_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 *","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);
  {
    try {
      (arg1)->setScale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_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_set_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_set_scale__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Node.set_scale", 
    "    void Node.set_scale(Ogre::Vector3 const &scale)\n"
    "    void Node.set_scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_scale

  call-seq:
    get_scale -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_scale(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Node const *)arg1)->getScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.set_inherit_orientation

  call-seq:
    set_inherit_orientation(bool inherit)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_set_inherit_orientation(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);
  {
    try {
      (arg1)->setInheritOrientation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_inherit_orientation

  call-seq:
    get_inherit_orientation -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_inherit_orientation(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);
  {
    try {
      result = (bool)((Ogre::Node const *)arg1)->getInheritOrientation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.set_inherit_scale

  call-seq:
    set_inherit_scale(bool inherit)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_set_inherit_scale(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);
  {
    try {
      (arg1)->setInheritScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_inherit_scale

  call-seq:
    get_inherit_scale -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_inherit_scale(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);
  {
    try {
      result = (bool)((Ogre::Node const *)arg1)->getInheritScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.scale

  call-seq:
    scale(Vector3 scale)
    scale(Real x, Real y, Real z)

An instance method.

*/
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);
  {
    try {
      (arg1)->scale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->scale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::Node.translate

  call-seq:
    translate(Vector3 d, TransformSpace relativeTo=TS_PARENT)
    translate(Vector3 d)
    translate(Real x, Real y, Real z, TransformSpace relativeTo=TS_PARENT)
    translate(Real x, Real y, Real z)
    translate(Matrix3 axes, Vector3 move, TransformSpace relativeTo=TS_PARENT)
    translate(Matrix3 axes, Vector3 move)
    translate(Matrix3 axes, Real x, Real y, Real z, TransformSpace relativeTo=TS_PARENT)
    translate(Matrix3 axes, Real x, Real y, Real z)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->translate((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->translate(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->translate(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->translate((Ogre::Matrix3 const &)*arg2,(Ogre::Vector3 const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->translate((Ogre::Matrix3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->translate((Ogre::Matrix3 const &)*arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->translate((Ogre::Matrix3 const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::Node.roll

  call-seq:
    roll(Radian angle, TransformSpace relativeTo=TS_LOCAL)
    roll(Radian angle)

An instance method.

*/
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);
  {
    try {
      (arg1)->roll((Ogre::Radian const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->roll((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Node.pitch

  call-seq:
    pitch(Radian angle, TransformSpace relativeTo=TS_LOCAL)
    pitch(Radian angle)

An instance method.

*/
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);
  {
    try {
      (arg1)->pitch((Ogre::Radian const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->pitch((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Node.yaw

  call-seq:
    yaw(Radian angle, TransformSpace relativeTo=TS_LOCAL)
    yaw(Radian angle)

An instance method.

*/
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);
  {
    try {
      (arg1)->yaw((Ogre::Radian const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->yaw((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Node.rotate

  call-seq:
    rotate(Vector3 axis, Radian angle, TransformSpace relativeTo=TS_LOCAL)
    rotate(Vector3 axis, Radian angle)
    rotate(Quaternion q, TransformSpace relativeTo=TS_LOCAL)
    rotate(Quaternion q)

An instance method.

*/
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);
  {
    try {
      (arg1)->rotate((Ogre::Vector3 const &)*arg2,(Ogre::Radian const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->rotate((Ogre::Vector3 const &)*arg2,(Ogre::Radian const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->rotate((Ogre::Quaternion const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->rotate((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::Node.get_local_axes

  call-seq:
    get_local_axes -> Matrix3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_local_axes(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);
  {
    try {
      result = ((Ogre::Node const *)arg1)->getLocalAxes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.create_child

  call-seq:
    create_child(Vector3 translate=, Quaternion rotate=IDENTITY) -> Node
    create_child(Vector3 translate=) -> Node
    create_child -> Node
    create_child(String name, Vector3 translate=, Quaternion rotate=IDENTITY) -> Node
    create_child(String name, Vector3 translate=) -> Node
    create_child(String name) -> Node

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_create_child__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);
  {
    try {
      result = (Ogre::Node *)(arg1)->createChild((Ogre::Vector3 const &)*arg2,(Ogre::Quaternion const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_create_child__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);
  {
    try {
      result = (Ogre::Node *)(arg1)->createChild((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_create_child__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);
  {
    try {
      result = (Ogre::Node *)(arg1)->createChild();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_create_child__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);
  {
    try {
      result = (Ogre::Node *)(arg1)->createChild((Ogre::String const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_child__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);
  {
    try {
      result = (Ogre::Node *)(arg1)->createChild((Ogre::String const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_child__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;
  }
  {
    try {
      result = (Ogre::Node *)(arg1)->createChild((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_child(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_create_child__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_create_child__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_create_child__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_create_child__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_create_child__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_create_child__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Node.create_child", 
    "    Ogre::Node * Node.create_child(Ogre::Vector3 const &translate, Ogre::Quaternion const &rotate)\n"
    "    Ogre::Node * Node.create_child(Ogre::Vector3 const &translate)\n"
    "    Ogre::Node * Node.create_child()\n"
    "    Ogre::Node * Node.create_child(Ogre::String const &name, Ogre::Vector3 const &translate, Ogre::Quaternion const &rotate)\n"
    "    Ogre::Node * Node.create_child(Ogre::String const &name, Ogre::Vector3 const &translate)\n"
    "    Ogre::Node * Node.create_child(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Node.add_child

  call-seq:
    add_child(Node child)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_add_child(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);
  {
    try {
      (arg1)->addChild(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.num_children

  call-seq:
    num_children -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_num_children(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);
  {
    try {
      result = (unsigned short)((Ogre::Node const *)arg1)->numChildren();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_child

  call-seq:
    get_child(unsigned short index) -> Node
    get_child(String name) -> Node

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_child__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);
  {
    try {
      result = (Ogre::Node *)((Ogre::Node const *)arg1)->getChild(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_get_child__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;
  }
  {
    try {
      result = (Ogre::Node *)((Ogre::Node const *)arg1)->getChild((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_child(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_get_child__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_get_child__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Node.get_child", 
    "    Ogre::Node * Node.get_child(unsigned short index)\n"
    "    Ogre::Node * Node.get_child(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Node.remove_child

  call-seq:
    remove_child(unsigned short index) -> Node
    remove_child(Node child) -> Node
    remove_child(String name) -> Node

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_remove_child__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);
  {
    try {
      result = (Ogre::Node *)(arg1)->removeChild(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_remove_child__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);
  {
    try {
      result = (Ogre::Node *)(arg1)->removeChild(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_remove_child__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;
  }
  {
    try {
      result = (Ogre::Node *)(arg1)->removeChild((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_remove_child(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_remove_child__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_remove_child__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_remove_child__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Node.remove_child", 
    "    Ogre::Node * Node.remove_child(unsigned short index)\n"
    "    Ogre::Node * Node.remove_child(Ogre::Node *child)\n"
    "    Ogre::Node * Node.remove_child(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Node.remove_all_children

  call-seq:
    remove_all_children

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_remove_all_children(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);
  {
    try {
      (arg1)->removeAllChildren();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node._set_derived_position

  call-seq:
    _set_derived_position(Vector3 pos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node__set_derived_position(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);
  {
    try {
      (arg1)->_setDerivedPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node._set_derived_orientation

  call-seq:
    _set_derived_orientation(Quaternion q)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node__set_derived_orientation(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);
  {
    try {
      (arg1)->_setDerivedOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node._get_derived_orientation

  call-seq:
    _get_derived_orientation -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node__get_derived_orientation(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);
  {
    try {
      result = (Ogre::Quaternion *) &((Ogre::Node const *)arg1)->_getDerivedOrientation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node._get_derived_position

  call-seq:
    _get_derived_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node__get_derived_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Node const *)arg1)->_getDerivedPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node._get_derived_scale

  call-seq:
    _get_derived_scale -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node__get_derived_scale(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Node const *)arg1)->_getDerivedScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node._get_full_transform

  call-seq:
    _get_full_transform -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node__get_full_transform(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::Node const *)arg1)->_getFullTransform();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node._update

  call-seq:
    _update(bool updateChildren, bool parentHasChanged)

An instance method.

*/
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);
  {
    try {
      (arg1)->_update(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.set_listener

  call-seq:
    set_listener(Listener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_set_listener(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);
  {
    try {
      (arg1)->setListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_listener

  call-seq:
    get_listener -> Listener

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_listener(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);
  {
    try {
      result = (Ogre::Node::Listener *)((Ogre::Node const *)arg1)->getListener();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node__Listener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.set_initial_state

  call-seq:
    set_initial_state

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_set_initial_state(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);
  {
    try {
      (arg1)->setInitialState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.reset_to_initial_state

  call-seq:
    reset_to_initial_state

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_reset_to_initial_state(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);
  {
    try {
      (arg1)->resetToInitialState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_initial_position

  call-seq:
    get_initial_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_initial_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Node const *)arg1)->getInitialPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.convert_world_to_local_position

  call-seq:
    convert_world_to_local_position(Vector3 worldPos) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_convert_world_to_local_position(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);
  {
    try {
      result = (arg1)->convertWorldToLocalPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.convert_local_to_world_position

  call-seq:
    convert_local_to_world_position(Vector3 localPos) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_convert_local_to_world_position(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);
  {
    try {
      result = (arg1)->convertLocalToWorldPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.convert_world_to_local_orientation

  call-seq:
    convert_world_to_local_orientation(Quaternion worldOrientation) -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_convert_world_to_local_orientation(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);
  {
    try {
      result = (arg1)->convertWorldToLocalOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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::Node.convert_local_to_world_orientation

  call-seq:
    convert_local_to_world_orientation(Quaternion localOrientation) -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_convert_local_to_world_orientation(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);
  {
    try {
      result = (arg1)->convertLocalToWorldOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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::Node.get_initial_orientation

  call-seq:
    get_initial_orientation -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_initial_orientation(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);
  {
    try {
      result = (Ogre::Quaternion *) &((Ogre::Node const *)arg1)->getInitialOrientation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_initial_scale

  call-seq:
    get_initial_scale -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_initial_scale(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Node const *)arg1)->getInitialScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera cam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Node const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.need_update

  call-seq:
    need_update(bool forceParentUpdate=false)
    need_update

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_need_update__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);
  {
    try {
      (arg1)->needUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_need_update__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);
  {
    try {
      (arg1)->needUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_need_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__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Node_need_update__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_need_update__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Node.need_update", 
    "    void Node.need_update(bool forceParentUpdate)\n"
    "    void Node.need_update()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Node.request_update

  call-seq:
    request_update(Node child, bool forceParentUpdate=false)
    request_update(Node child)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_request_update__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);
  {
    try {
      (arg1)->requestUpdate(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_request_update__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);
  {
    try {
      (arg1)->requestUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_request_update(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_request_update__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_request_update__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Node.request_update", 
    "    void Node.request_update(Ogre::Node *child, bool forceParentUpdate)\n"
    "    void Node.request_update(Ogre::Node *child)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Node.cancel_update

  call-seq:
    cancel_update(Node child)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_cancel_update(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);
  {
    try {
      (arg1)->cancelUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_debug_renderable

  call-seq:
    get_debug_renderable(Real scaling) -> DebugRenderable

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_debug_renderable(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);
  {
    try {
      result = (Ogre::Node::DebugRenderable *)(arg1)->getDebugRenderable(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node__DebugRenderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.queue_need_update

  call-seq:
    queue_need_update(Node n)

A class method.

*/
SWIGINTERN VALUE
_wrap_Node_queue_need_update(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);
  {
    try {
      Ogre::Node::queueNeedUpdate(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.process_queued_updates

  call-seq:
    process_queued_updates

A class method.

*/
SWIGINTERN VALUE
_wrap_Node_process_queued_updates(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      Ogre::Node::processQueuedUpdates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.set_user_any

  call-seq:
    set_user_any(Any anything)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_set_user_any(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);
  {
    try {
      (arg1)->setUserAny((Ogre::Any const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_user_any

  call-seq:
    get_user_any -> Any

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_user_any(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);
  {
    try {
      result = (Ogre::Any *) &((Ogre::Node const *)arg1)->getUserAny();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Node.get_user_object_bindings

  call-seq:
    get_user_object_bindings -> UserObjectBindings
    get_user_object_bindings -> UserObjectBindings

An instance method.

*/
SWIGINTERN VALUE
_wrap_Node_get_user_object_bindings__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);
  {
    try {
      result = (Ogre::UserObjectBindings *) &(arg1)->getUserObjectBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_get_user_object_bindings__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);
  {
    try {
      result = (Ogre::UserObjectBindings *) &((Ogre::Node const *)arg1)->getUserObjectBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_get_user_object_bindings(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_get_user_object_bindings__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_get_user_object_bindings__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Node.get_user_object_bindings", 
    "    Ogre::UserObjectBindings const & Node.get_user_object_bindings()\n"
    "    Ogre::UserObjectBindings const & Node.get_user_object_bindings()\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::Bone < Ogre::Ogre::Node

  Proxy of C++ Ogre::Bone class


*/
swig_class SwigClassBone;


/*
  Document-method: Ogre::Bone.new

  call-seq:
    Bone.new(unsigned short handle, Skeleton creator)
    Bone.new(String name, unsigned short handle, Skeleton creator)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Bone *)new Ogre::Bone(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::Bone *)new Ogre::Bone((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::Bone.create_child

  call-seq:
    create_child(unsigned short handle, Vector3 translate=, Quaternion rotate=IDENTITY) -> Bone
    create_child(unsigned short handle, Vector3 translate=) -> Bone
    create_child(unsigned short handle) -> Bone

An instance method.

*/
SWIGINTERN VALUE
_wrap_Bone_create_child__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);
  {
    try {
      result = (Ogre::Bone *)(arg1)->createChild(arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone_create_child__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);
  {
    try {
      result = (Ogre::Bone *)(arg1)->createChild(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone_create_child__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);
  {
    try {
      result = (Ogre::Bone *)(arg1)->createChild(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Bone_create_child(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_create_child__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_create_child__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_create_child__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Bone.create_child", 
    "    Ogre::Bone * Bone.create_child(unsigned short handle, Ogre::Vector3 const &translate, Ogre::Quaternion const &rotate)\n"
    "    Ogre::Bone * Bone.create_child(unsigned short handle, Ogre::Vector3 const &translate)\n"
    "    Ogre::Bone * Bone.create_child(unsigned short handle)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Bone.get_handle

  call-seq:
    get_handle -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Bone_get_handle(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);
  {
    try {
      result = (unsigned short)((Ogre::Bone const *)arg1)->getHandle();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bone.set_binding_pose

  call-seq:
    set_binding_pose

An instance method.

*/
SWIGINTERN VALUE
_wrap_Bone_set_binding_pose(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);
  {
    try {
      (arg1)->setBindingPose();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bone.reset

  call-seq:
    reset

An instance method.

*/
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);
  {
    try {
      (arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bone.set_manually_controlled

  call-seq:
    set_manually_controlled(bool manuallyControlled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Bone_set_manually_controlled(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);
  {
    try {
      (arg1)->setManuallyControlled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bone.is_manually_controlled

  call-seq:
    is_manually_controlled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Bone_is_manually_controlled(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);
  {
    try {
      result = (bool)((Ogre::Bone const *)arg1)->isManuallyControlled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bone._get_offset_transform

  call-seq:
    _get_offset_transform(Matrix4 m)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Bone__get_offset_transform(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);
  {
    try {
      ((Ogre::Bone const *)arg1)->_getOffsetTransform(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bone._get_binding_pose_inverse_scale

  call-seq:
    _get_binding_pose_inverse_scale -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Bone__get_binding_pose_inverse_scale(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Bone const *)arg1)->_getBindingPoseInverseScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bone._get_binding_pose_inverse_position

  call-seq:
    _get_binding_pose_inverse_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Bone__get_binding_pose_inverse_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Bone const *)arg1)->_getBindingPoseInversePosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bone._get_binding_pose_inverse_orientation

  call-seq:
    _get_binding_pose_inverse_orientation -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Bone__get_binding_pose_inverse_orientation(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);
  {
    try {
      result = (Ogre::Quaternion *) &((Ogre::Bone const *)arg1)->_getBindingPoseInverseOrientation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Bone.need_update

  call-seq:
    need_update(bool forceParentUpdate=false)
    need_update

An instance method.

*/
SWIGINTERN VALUE
_wrap_Bone_need_update__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);
  {
    try {
      (arg1)->needUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone_need_update__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);
  {
    try {
      (arg1)->needUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Bone_need_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__Bone, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Bone_need_update__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_need_update__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Bone.need_update", 
    "    void Bone.need_update(bool forceParentUpdate)\n"
    "    void Bone.need_update()\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::UTFString

  Proxy of C++ Ogre::UTFString class


*/
swig_class SwigClassUTFString;


/*
  Document-method: Ogre::UTFString.NPOS

  call-seq:
    NPOS -> size_type

Get value of attribute.

*/

/*
  Document-method: Ogre::UTFString.NPOS

  call-seq:
    NPOS -> size_t

A class method.

*/

/*
  Document-method: Ogre::UTFString.new

  call-seq:
    UTFString.new
    UTFString.new(UTFString copy)
    UTFString.new(size_type length, code_point ch)
    UTFString.new(code_point str)
    UTFString.new(code_point str, size_type length)
    UTFString.new(UTFString str, size_type index, size_type length)
    UTFString.new(std::wstring wstr)
    UTFString.new(char c_str)
    UTFString.new(char c_str, size_type length)
    UTFString.new(string str)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::UTFString *)new Ogre::UTFString();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::UTFString *)new Ogre::UTFString((Ogre::UTFString const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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;
  {
    try {
      result = (Ogre::UTFString *)new Ogre::UTFString(arg1,(Ogre::UTFString::code_point const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::UTFString *)new Ogre::UTFString((Ogre::UTFString::code_point const *)arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::UTFString *)new Ogre::UTFString((Ogre::UTFString::code_point const *)arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::UTFString *)new Ogre::UTFString((Ogre::UTFString const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::UTFString *)new Ogre::UTFString((std::wstring const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::UTFString *)new Ogre::UTFString((char const *)arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::UTFString *)new Ogre::UTFString((char const *)arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::UTFString *)new Ogre::UTFString((std::string const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->size();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->length();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.length_characters

  call-seq:
    length_characters -> size_type

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->length_Characters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->max_size();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      (arg1)->reserve(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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;
  {
    try {
      (arg1)->resize(arg2,(Ogre::UTFString::code_point const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->resize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::UTFString.swap

  call-seq:
    swap(UTFString from)

An instance method.

*/
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);
  {
    try {
      (arg1)->swap(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::UTFString const *)arg1)->empty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (Ogre::UTFString::code_point *)((Ogre::UTFString const *)arg1)->c_str();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.data

  call-seq:
    data -> code_point

An instance method.

*/
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);
  {
    try {
      result = (Ogre::UTFString::code_point *)((Ogre::UTFString const *)arg1)->data();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->capacity();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->substr(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->substr(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      (arg1)->push_back(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->push_back(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->push_back(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::UTFString.in_string

  call-seq:
    in_string(unicode_char ch) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UTFString_in_string(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);
  {
    try {
      result = (bool)((Ogre::UTFString const *)arg1)->inString(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.as_utf8

  call-seq:
    as_utf8 -> string

An instance method.

*/
SWIGINTERN VALUE
_wrap_UTFString_as_utf8(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);
  {
    try {
      result = (std::string *) &((Ogre::UTFString const *)arg1)->asUTF8();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.as_utf_8_c_str

  call-seq:
    as_utf_8_c_str -> char

An instance method.

*/
SWIGINTERN VALUE
_wrap_UTFString_as_utf_8_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);
  {
    try {
      result = (char *)((Ogre::UTFString const *)arg1)->asUTF8_c_str();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.as_utf_32

  call-seq:
    as_utf_32 -> utf32string

An instance method.

*/
SWIGINTERN VALUE
_wrap_UTFString_as_utf_32(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);
  {
    try {
      result = (Ogre::UTFString::utf32string *) &((Ogre::UTFString const *)arg1)->asUTF32();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_unsigned_int_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.as_utf_32_c_str

  call-seq:
    as_utf_32_c_str -> unicode_char

An instance method.

*/
SWIGINTERN VALUE
_wrap_UTFString_as_utf_32_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);
  {
    try {
      result = (Ogre::UTFString::unicode_char *)((Ogre::UTFString const *)arg1)->asUTF32_c_str();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.as_wstr

  call-seq:
    as_wstr -> std::wstring

An instance method.

*/
SWIGINTERN VALUE
_wrap_UTFString_as_wstr(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);
  {
    try {
      result = (std::wstring *) &((Ogre::UTFString const *)arg1)->asWStr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__wstring, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.as_wstr_c_str

  call-seq:
    as_wstr_c_str -> wchar_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_UTFString_as_wstr_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);
  {
    try {
      result = (wchar_t *)((Ogre::UTFString const *)arg1)->asWStr_c_str();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().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);
  {
    try {
      result = (Ogre::UTFString::code_point *) &(arg1)->at(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::UTFString::code_point *) &((Ogre::UTFString const *)arg1)->at(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
}



/*
  Document-method: Ogre::UTFString.get_char

  call-seq:
    get_char(size_type loc) -> unicode_char

An instance method.

*/
SWIGINTERN VALUE
_wrap_UTFString_get_char(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);
  {
    try {
      result = (Ogre::UTFString::unicode_char)((Ogre::UTFString const *)arg1)->getChar(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.set_char

  call-seq:
    set_char(size_type loc, unicode_char ch) -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_UTFString_set_char(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);
  {
    try {
      result = (int)(arg1)->setChar(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (arg1)->begin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->begin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->end();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->end();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->rbegin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->rbegin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->rend();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->rend();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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));
    }
  }
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->assign(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->assign((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->assign((Ogre::UTFString::code_point const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->assign((Ogre::UTFString::code_point const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->assign((Ogre::UTFString const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->assign(arg2,(Ogre::UTFString::code_point const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->assign((std::wstring const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
  }
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->assign((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->assign((char const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->assign((char const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
}



/*
  Document-method: Ogre::UTFString.append

  call-seq:
    append(UTFString str) -> UTFString
    append(code_point str) -> UTFString
    append(UTFString str, size_type index, size_type len) -> UTFString
    append(code_point str, size_type num) -> UTFString
    append(size_type num, code_point ch) -> UTFString
    append(iterator start, iterator end) -> UTFString
    append(char c_str, size_type num) -> UTFString
    append(size_type num, char ch) -> UTFString
    append(size_type num, unicode_char ch) -> UTFString

An instance method.

*/
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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->append((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->append((Ogre::UTFString::code_point const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->append((Ogre::UTFString const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->append((Ogre::UTFString::code_point const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->append(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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));
    }
  }
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->append(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->append((char const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->append(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->append(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
  {
    try {
      result = (arg1)->insert(arg2,(Ogre::UTFString::code_point const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->insert(arg2,(Ogre::UTFString const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->insert(arg2,(Ogre::UTFString::code_point const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->insert(arg2,(Ogre::UTFString const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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));
    }
  }
  {
    try {
      (arg1)->insert(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->insert(arg2,(Ogre::UTFString::code_point const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->insert(arg2,(char const *)arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->insert(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->insert(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->insert(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
  {
    try {
      (arg1)->insert(arg2,arg3,(Ogre::UTFString::code_point const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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;
  {
    try {
      (arg1)->insert(arg2,arg3,(char const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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;
  {
    try {
      (arg1)->insert(arg2,arg3,(Ogre::UTFString::unicode_char const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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));
    }
  }
  {
    try {
      result = (arg1)->erase(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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));
    }
  }
  {
    try {
      result = (arg1)->erase(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->erase(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->erase(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->erase();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,(Ogre::UTFString const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,(Ogre::UTFString const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,(Ogre::UTFString const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,(Ogre::UTFString const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,(Ogre::UTFString const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
}



/*
  Document-method: Ogre::UTFString.compare

  call-seq:
    compare(UTFString str) -> int
    compare(code_point str) -> int
    compare(size_type index, size_type length, UTFString str) -> int
    compare(size_type index, size_type length, UTFString str, size_type index2, 
    size_type length2) -> int
    compare(size_type index, size_type length, code_point str, 
    size_type length2) -> int
    compare(size_type index, size_type length, char c_str, size_type length2) -> int

An instance method.

*/
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);
  {
    try {
      result = (int)((Ogre::UTFString const *)arg1)->compare((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (int)((Ogre::UTFString const *)arg1)->compare((Ogre::UTFString::code_point const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (int)((Ogre::UTFString const *)arg1)->compare(arg2,arg3,(Ogre::UTFString const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = (int)((Ogre::UTFString const *)arg1)->compare(arg2,arg3,(Ogre::UTFString const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (int)((Ogre::UTFString const *)arg1)->compare(arg2,arg3,(Ogre::UTFString::code_point const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = (int)((Ogre::UTFString const *)arg1)->compare(arg2,arg3,(char const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find((Ogre::UTFString const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find((Ogre::UTFString::code_point const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find((char const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->rfind((Ogre::UTFString const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->rfind((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->rfind((Ogre::UTFString::code_point const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->rfind((char const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->rfind(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->rfind(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->rfind(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->rfind(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->rfind(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
}



/*
  Document-method: Ogre::UTFString.find_first_of

  call-seq:
    find_first_of(UTFString str, size_type index=0, size_type num=NPOS) -> size_type
    find_first_of(UTFString str, size_type index=0) -> size_type
    find_first_of(UTFString str) -> size_type
    find_first_of(code_point ch, size_type index=0) -> size_type
    find_first_of(code_point ch) -> size_type
    find_first_of(char ch, size_type index=0) -> size_type
    find_first_of(char ch) -> size_type
    find_first_of(unicode_char ch, size_type index=0) -> size_type
    find_first_of(unicode_char ch) -> size_type

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_of((Ogre::UTFString const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_of((Ogre::UTFString const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_of((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_of(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_of(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_of(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_of(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_of(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_of(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
}



/*
  Document-method: Ogre::UTFString.find_first_not_of

  call-seq:
    find_first_not_of(UTFString str, size_type index=0, size_type num=NPOS) -> size_type
    find_first_not_of(UTFString str, size_type index=0) -> size_type
    find_first_not_of(UTFString str) -> size_type
    find_first_not_of(code_point ch, size_type index=0) -> size_type
    find_first_not_of(code_point ch) -> size_type
    find_first_not_of(char ch, size_type index=0) -> size_type
    find_first_not_of(char ch) -> size_type
    find_first_not_of(unicode_char ch, size_type index=0) -> size_type
    find_first_not_of(unicode_char ch) -> size_type

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_not_of((Ogre::UTFString const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_not_of((Ogre::UTFString const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_not_of((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_not_of(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_not_of(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_not_of(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_not_of(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_not_of(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_first_not_of(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
}



/*
  Document-method: Ogre::UTFString.find_last_of

  call-seq:
    find_last_of(UTFString str, size_type index=NPOS, size_type num=NPOS) -> size_type
    find_last_of(UTFString str, size_type index=NPOS) -> size_type
    find_last_of(UTFString str) -> size_type
    find_last_of(code_point ch, size_type index=NPOS) -> size_type
    find_last_of(code_point ch) -> size_type
    find_last_of(char ch, size_type index=NPOS) -> size_type
    find_last_of(char ch) -> size_type
    find_last_of(unicode_char ch, size_type index=NPOS) -> size_type
    find_last_of(unicode_char ch) -> size_type

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_of((Ogre::UTFString const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_of((Ogre::UTFString const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_of((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_of(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_of(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_of(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_of(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_of(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_of(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
}



/*
  Document-method: Ogre::UTFString.find_last_not_of

  call-seq:
    find_last_not_of(UTFString str, size_type index=NPOS, size_type num=NPOS) -> size_type
    find_last_not_of(UTFString str, size_type index=NPOS) -> size_type
    find_last_not_of(UTFString str) -> size_type
    find_last_not_of(code_point ch, size_type index=NPOS) -> size_type
    find_last_not_of(code_point ch) -> size_type
    find_last_not_of(char ch, size_type index=NPOS) -> size_type
    find_last_not_of(char ch) -> size_type
    find_last_not_of(unicode_char ch, size_type index=NPOS) -> size_type
    find_last_not_of(unicode_char ch) -> size_type

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_not_of((Ogre::UTFString const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_not_of((Ogre::UTFString const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_not_of((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_not_of(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_not_of(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_not_of(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_not_of(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_not_of(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = ((Ogre::UTFString const *)arg1)->find_last_not_of(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (bool)((Ogre::UTFString const *)arg1)->operator <((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::UTFString const *)arg1)->operator <=((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::UTFString const *)arg1)->operator >((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::UTFString const *)arg1)->operator >=((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::UTFString const *)arg1)->operator ==((Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString._utf_16_independent_char

  call-seq:
    _utf_16_independent_char(code_point cp) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_UTFString__utf_16_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);
  {
    try {
      result = (bool)Ogre::UTFString::_utf16_independent_char(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString._utf_16_surrogate_lead

  call-seq:
    _utf_16_surrogate_lead(code_point cp) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_UTFString__utf_16_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);
  {
    try {
      result = (bool)Ogre::UTFString::_utf16_surrogate_lead(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString._utf_16_surrogate_follow

  call-seq:
    _utf_16_surrogate_follow(code_point cp) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_UTFString__utf_16_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);
  {
    try {
      result = (bool)Ogre::UTFString::_utf16_surrogate_follow(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString._utf_16_char_length

  call-seq:
    _utf_16_char_length(code_point cp) -> size_t
    _utf_16_char_length(unicode_char uc) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_UTFString__utf_16_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);
  {
    try {
      result = Ogre::UTFString::_utf16_char_length(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf_16_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);
  {
    try {
      result = Ogre::UTFString::_utf16_char_length(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString__utf_16_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__utf_16_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__utf_16_char_length__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UTFString._utf_16_char_length", 
    "    size_t UTFString._utf_16_char_length(Ogre::UTFString::code_point cp)\n"
    "    size_t UTFString._utf_16_char_length(Ogre::UTFString::unicode_char uc)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString._utf_16_to_utf_32

  call-seq:
    _utf_16_to_utf_32(code_point in_cp, unicode_char out_uc) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_UTFString__utf_16_to_utf_32(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);
  {
    try {
      result = Ogre::UTFString::_utf16_to_utf32((unsigned short const (*))arg1,*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString._utf_32_to_utf_16

  call-seq:
    _utf_32_to_utf_16(unicode_char in_uc, code_point out_cp) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_UTFString__utf_32_to_utf_16(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);
  {
    try {
      result = Ogre::UTFString::_utf32_to_utf16((unsigned int const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString._utf_8_start_char

  call-seq:
    _utf_8_start_char(unsigned char cp) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_UTFString__utf_8_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);
  {
    try {
      result = (bool)Ogre::UTFString::_utf8_start_char(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString._utf_8_char_length

  call-seq:
    _utf_8_char_length(unsigned char cp) -> size_t
    _utf_8_char_length(unicode_char uc) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_UTFString__utf_8_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);
  {
    try {
      result = Ogre::UTFString::_utf8_char_length(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf_8_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);
  {
    try {
      result = Ogre::UTFString::_utf8_char_length(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString__utf_8_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__utf_8_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__utf_8_char_length__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UTFString._utf_8_char_length", 
    "    size_t UTFString._utf_8_char_length(unsigned char cp)\n"
    "    size_t UTFString._utf_8_char_length(Ogre::UTFString::unicode_char uc)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString._utf_8_to_utf_32

  call-seq:
    _utf_8_to_utf_32(unsigned char in_cp, unicode_char out_uc) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_UTFString__utf_8_to_utf_32(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);
  {
    try {
      result = Ogre::UTFString::_utf8_to_utf32((unsigned char const (*))arg1,*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString._utf_32_to_utf8

  call-seq:
    _utf_32_to_utf8(unicode_char in_uc, unsigned char out_cp) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_UTFString__utf_32_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);
  {
    try {
      result = Ogre::UTFString::_utf32_to_utf8((unsigned int const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString._verify_utf8

  call-seq:
    _verify_utf8(unsigned char c_str) -> size_type
    _verify_utf8(string str) -> size_type

A class method.

*/
SWIGINTERN VALUE
_wrap_UTFString__verify_utf8__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);
  {
    try {
      result = Ogre::UTFString::_verifyUTF8((unsigned char const *)arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__verify_utf8__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;
  }
  {
    try {
      result = Ogre::UTFString::_verifyUTF8((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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__verify_utf8(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__verify_utf8__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__verify_utf8__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UTFString._verify_utf8", 
    "    Ogre::UTFString::size_type UTFString._verify_utf8(unsigned char const *c_str)\n"
    "    Ogre::UTFString::size_type UTFString._verify_utf8(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);
  {
    try {
      result = Ogre::operator +((Ogre::UTFString const &)*arg1,(Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = Ogre::operator +((Ogre::UTFString const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = Ogre::operator +((Ogre::UTFString const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = Ogre::operator +((Ogre::UTFString const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = Ogre::operator +(arg1,(Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = Ogre::operator +(arg1,(Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = Ogre::operator +(arg1,(Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = Ogre::operator -((Ogre::UTFString::_const_fwd_iterator const &)*arg1,(Ogre::UTFString::_const_fwd_iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (bool)Ogre::operator ==((Ogre::UTFString::_const_fwd_iterator const &)*arg1,(Ogre::UTFString::_const_fwd_iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)Ogre::operator <((Ogre::UTFString::_const_fwd_iterator const &)*arg1,(Ogre::UTFString::_const_fwd_iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)Ogre::operator <=((Ogre::UTFString::_const_fwd_iterator const &)*arg1,(Ogre::UTFString::_const_fwd_iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)Ogre::operator >((Ogre::UTFString::_const_fwd_iterator const &)*arg1,(Ogre::UTFString::_const_fwd_iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)Ogre::operator >=((Ogre::UTFString::_const_fwd_iterator const &)*arg1,(Ogre::UTFString::_const_fwd_iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = Ogre::operator -((Ogre::UTFString::_const_rev_iterator const &)*arg1,(Ogre::UTFString::_const_rev_iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (bool)Ogre::operator ==((Ogre::UTFString::_const_rev_iterator const &)*arg1,(Ogre::UTFString::_const_rev_iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)Ogre::operator <((Ogre::UTFString::_const_rev_iterator const &)*arg1,(Ogre::UTFString::_const_rev_iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___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);
  {
    try {
      result = (bool)Ogre::operator <=((Ogre::UTFString::_const_rev_iterator const &)*arg1,(Ogre::UTFString::_const_rev_iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___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);
  {
    try {
      result = (bool)Ogre::operator >((Ogre::UTFString::_const_rev_iterator const &)*arg1,(Ogre::UTFString::_const_rev_iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___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);
  {
    try {
      result = (bool)Ogre::operator >=((Ogre::UTFString::_const_rev_iterator const &)*arg1,(Ogre::UTFString::_const_rev_iterator const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___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);
  {
    try {
      result = (std::ostream *) &Ogre::operator <<(*arg1,(Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (std::wostream *) &Ogre::operator <<(*arg1,(Ogre::UTFString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
}



/*
  Document-class: Ogre::CmdLeft < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdLeft class


*/
swig_class SwigClassCmdLeft;


/*
  Document-method: Ogre::CmdLeft.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdLeft_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::OverlayElementCommands::CmdLeft const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdLeft.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdLeft_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdLeft.new

  call-seq:
    CmdLeft.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::OverlayElementCommands::CmdLeft *)new Ogre::OverlayElementCommands::CmdLeft();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdLeft(Ogre::OverlayElementCommands::CmdLeft *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdTop < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdTop class


*/
swig_class SwigClassCmdTop;


/*
  Document-method: Ogre::CmdTop.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdTop_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::OverlayElementCommands::CmdTop const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdTop.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdTop_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdTop.new

  call-seq:
    CmdTop.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::OverlayElementCommands::CmdTop *)new Ogre::OverlayElementCommands::CmdTop();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdTop(Ogre::OverlayElementCommands::CmdTop *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdWidth < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdWidth class


*/
swig_class SwigClassCmdWidth;


/*
  Document-method: Ogre::CmdWidth.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdWidth_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::OverlayElementCommands::CmdWidth const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdWidth.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdWidth_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdWidth.new

  call-seq:
    CmdWidth.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::OverlayElementCommands::CmdWidth *)new Ogre::OverlayElementCommands::CmdWidth();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdWidth(Ogre::OverlayElementCommands::CmdWidth *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdHeight < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdHeight class


*/
swig_class SwigClassCmdHeight;


/*
  Document-method: Ogre::CmdHeight.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdHeight_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::OverlayElementCommands::CmdHeight const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdHeight.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdHeight_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdHeight.new

  call-seq:
    CmdHeight.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::OverlayElementCommands::CmdHeight *)new Ogre::OverlayElementCommands::CmdHeight();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdHeight(Ogre::OverlayElementCommands::CmdHeight *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdMaterial < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdMaterial class


*/
swig_class SwigClassCmdMaterial;


/*
  Document-method: Ogre::CmdMaterial.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMaterial_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::OverlayElementCommands::CmdMaterial const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdMaterial.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMaterial_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdMaterial.new

  call-seq:
    CmdMaterial.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::OverlayElementCommands::CmdMaterial *)new Ogre::OverlayElementCommands::CmdMaterial();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdMaterial(Ogre::OverlayElementCommands::CmdMaterial *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdCaption < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdCaption class


*/
swig_class SwigClassCmdCaption;


/*
  Document-method: Ogre::CmdCaption.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdCaption_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::OverlayElementCommands::CmdCaption const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdCaption.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdCaption_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdCaption.new

  call-seq:
    CmdCaption.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::OverlayElementCommands::CmdCaption *)new Ogre::OverlayElementCommands::CmdCaption();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdCaption(Ogre::OverlayElementCommands::CmdCaption *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdMetricsMode < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdMetricsMode class


*/
swig_class SwigClassCmdMetricsMode;


/*
  Document-method: Ogre::CmdMetricsMode.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMetricsMode_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::OverlayElementCommands::CmdMetricsMode const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdMetricsMode.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMetricsMode_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdMetricsMode.new

  call-seq:
    CmdMetricsMode.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::OverlayElementCommands::CmdMetricsMode *)new Ogre::OverlayElementCommands::CmdMetricsMode();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdMetricsMode(Ogre::OverlayElementCommands::CmdMetricsMode *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdHorizontalAlign < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdHorizontalAlign class


*/
swig_class SwigClassCmdHorizontalAlign;


/*
  Document-method: Ogre::CmdHorizontalAlign.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdHorizontalAlign_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::OverlayElementCommands::CmdHorizontalAlign const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdHorizontalAlign.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdHorizontalAlign_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdHorizontalAlign.new

  call-seq:
    CmdHorizontalAlign.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::OverlayElementCommands::CmdHorizontalAlign *)new Ogre::OverlayElementCommands::CmdHorizontalAlign();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdHorizontalAlign(Ogre::OverlayElementCommands::CmdHorizontalAlign *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdVerticalAlign < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdVerticalAlign class


*/
swig_class SwigClassCmdVerticalAlign;


/*
  Document-method: Ogre::CmdVerticalAlign.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdVerticalAlign_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::OverlayElementCommands::CmdVerticalAlign const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdVerticalAlign.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdVerticalAlign_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdVerticalAlign.new

  call-seq:
    CmdVerticalAlign.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::OverlayElementCommands::CmdVerticalAlign *)new Ogre::OverlayElementCommands::CmdVerticalAlign();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdVerticalAlign(Ogre::OverlayElementCommands::CmdVerticalAlign *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdVisible < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdVisible class


*/
swig_class SwigClassCmdVisible;


/*
  Document-method: Ogre::CmdVisible.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdVisible_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::OverlayElementCommands::CmdVisible const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdVisible.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdVisible_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdVisible.new

  call-seq:
    CmdVisible.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::OverlayElementCommands::CmdVisible *)new Ogre::OverlayElementCommands::CmdVisible();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdVisible(Ogre::OverlayElementCommands::CmdVisible *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::Rectangle

  Proxy of C++ Ogre::Rectangle class


*/
swig_class SwigClassRectangle;


/*
  Document-method: Ogre::Rectangle.left

  call-seq:
    left -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Rectangle.left=

  call-seq:
    left=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::Rectangle.top

  call-seq:
    top -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Rectangle.top=

  call-seq:
    top=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::Rectangle.right

  call-seq:
    right -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Rectangle.right=

  call-seq:
    right=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::Rectangle.bottom

  call-seq:
    bottom -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Rectangle.bottom=

  call-seq:
    bottom=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::Rectangle.inside

  call-seq:
    inside(Real x, Real y) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::Rectangle const *)arg1)->inside(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
  }
  


/*
  Document-method: Ogre::Rectangle.new

  call-seq:
    Rectangle.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Rectangle *)new Ogre::Rectangle();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Rectangle(Ogre::Rectangle *arg1) {
    delete arg1;
}


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

  call-seq:
    intersect(Rectangle lhs, Rectangle rhs) -> Rectangle

A module function.

*/
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);
  {
    try {
      result = Ogre::intersect((Ogre::Rectangle const &)*arg1,(Ogre::Rectangle const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Rectangle(static_cast< const Ogre::Rectangle& >(result))), SWIGTYPE_p_Ogre__Rectangle, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::OverlayElement < Ogre::Ogre::StringInterface, Ogre::Ogre::Renderable

  Proxy of C++ Ogre::OverlayElement class


*/
swig_class SwigClassOverlayElement;

SWIGINTERN void
free_Ogre_OverlayElement(Ogre::OverlayElement *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::OverlayElement.initialise

  call-seq:
    initialise

An instance method.

*/
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);
  {
    try {
      (arg1)->initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::OverlayElement const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.show

  call-seq:
    show

An instance method.

*/
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);
  {
    try {
      (arg1)->show();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.hide

  call-seq:
    hide

An instance method.

*/
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);
  {
    try {
      (arg1)->hide();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.is_visible

  call-seq:
    is_visible -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_is_visible(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);
  {
    try {
      result = (bool)((Ogre::OverlayElement const *)arg1)->isVisible();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.is_enabled

  call-seq:
    is_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_is_enabled(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);
  {
    try {
      result = (bool)((Ogre::OverlayElement const *)arg1)->isEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_enabled

  call-seq:
    set_enabled(bool b)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_enabled(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);
  {
    try {
      (arg1)->setEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_dimensions

  call-seq:
    set_dimensions(Real width, Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_dimensions(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);
  {
    try {
      (arg1)->setDimensions(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_position

  call-seq:
    set_position(Real left, Real top)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_position(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);
  {
    try {
      (arg1)->setPosition(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_width

  call-seq:
    set_width(Real width)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_width(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);
  {
    try {
      (arg1)->setWidth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_width

  call-seq:
    get_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->getWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_height

  call-seq:
    set_height(Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_height(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);
  {
    try {
      (arg1)->setHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_height

  call-seq:
    get_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->getHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_left

  call-seq:
    set_left(Real left)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_left(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);
  {
    try {
      (arg1)->setLeft(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_left

  call-seq:
    get_left -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_left(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);
  {
    try {
      result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->getLeft();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_top

  call-seq:
    set_top(Real Top)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_top(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);
  {
    try {
      (arg1)->setTop(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_top

  call-seq:
    get_top -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_top(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);
  {
    try {
      result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->getTop();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._get_left

  call-seq:
    _get_left -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__get_left(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);
  {
    try {
      result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->_getLeft();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._get_top

  call-seq:
    _get_top -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__get_top(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);
  {
    try {
      result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->_getTop();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._get_width

  call-seq:
    _get_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__get_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->_getWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._get_height

  call-seq:
    _get_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__get_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->_getHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._set_left

  call-seq:
    _set_left(Real left)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__set_left(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);
  {
    try {
      (arg1)->_setLeft(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._set_top

  call-seq:
    _set_top(Real top)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__set_top(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);
  {
    try {
      (arg1)->_setTop(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._set_width

  call-seq:
    _set_width(Real width)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__set_width(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);
  {
    try {
      (arg1)->_setWidth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._set_height

  call-seq:
    _set_height(Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__set_height(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);
  {
    try {
      (arg1)->_setHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._set_position

  call-seq:
    _set_position(Real left, Real top)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__set_position(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);
  {
    try {
      (arg1)->_setPosition(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._set_dimensions

  call-seq:
    _set_dimensions(Real width, Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__set_dimensions(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);
  {
    try {
      (arg1)->_setDimensions(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_material_name

  call-seq:
    get_material_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_material_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::OverlayElement const *)arg1)->getMaterialName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_material_name

  call-seq:
    set_material_name(String matName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_material_name(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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::OverlayElement const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_world_transforms(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);
  {
    try {
      ((Ogre::OverlayElement const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._positions_out_of_date

  call-seq:
    _positions_out_of_date

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__positions_out_of_date(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);
  {
    try {
      (arg1)->_positionsOutOfDate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._update

  call-seq:
    _update

An instance method.

*/
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);
  {
    try {
      (arg1)->_update();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._update_from_parent

  call-seq:
    _update_from_parent

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__update_from_parent(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);
  {
    try {
      (arg1)->_updateFromParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._notify_parent

  call-seq:
    _notify_parent(OverlayContainer parent, Overlay overlay)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__notify_parent(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);
  {
    try {
      (arg1)->_notifyParent(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._get_derived_left

  call-seq:
    _get_derived_left -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__get_derived_left(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);
  {
    try {
      result = (Ogre::Real)(arg1)->_getDerivedLeft();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._get_derived_top

  call-seq:
    _get_derived_top -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__get_derived_top(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);
  {
    try {
      result = (Ogre::Real)(arg1)->_getDerivedTop();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._get_relative_width

  call-seq:
    _get_relative_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__get_relative_width(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);
  {
    try {
      result = (Ogre::Real)(arg1)->_getRelativeWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._get_relative_height

  call-seq:
    _get_relative_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__get_relative_height(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);
  {
    try {
      result = (Ogre::Real)(arg1)->_getRelativeHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._get_clipping_region

  call-seq:
    _get_clipping_region(Rectangle clippingRegion)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__get_clipping_region(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);
  {
    try {
      (arg1)->_getClippingRegion(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._notify_zorder

  call-seq:
    _notify_zorder(ushort newZOrder) -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__notify_zorder(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);
  {
    try {
      result = (Ogre::ushort)(arg1)->_notifyZOrder(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._notify_world_transforms

  call-seq:
    _notify_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__notify_world_transforms(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);
  {
    try {
      (arg1)->_notifyWorldTransforms((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._notify_viewport

  call-seq:
    _notify_viewport

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__notify_viewport(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);
  {
    try {
      (arg1)->_notifyViewport();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayElement_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "OverlayElement.visit_renderables", 
    "    void OverlayElement.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void OverlayElement.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_type_name

  call-seq:
    get_type_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_type_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::OverlayElement const *)arg1)->getTypeName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_caption

  call-seq:
    set_caption(DisplayString text)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_caption(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);
  {
    try {
      (arg1)->setCaption((Ogre::DisplayString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_caption

  call-seq:
    get_caption -> DisplayString

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_caption(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);
  {
    try {
      result = (Ogre::DisplayString *) &((Ogre::OverlayElement const *)arg1)->getCaption();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_colour

  call-seq:
    set_colour(ColourValue col)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_colour(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);
  {
    try {
      (arg1)->setColour((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_colour

  call-seq:
    get_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::OverlayElement const *)arg1)->getColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_metrics_mode

  call-seq:
    set_metrics_mode(GuiMetricsMode gmm)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_metrics_mode(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);
  {
    try {
      (arg1)->setMetricsMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_metrics_mode

  call-seq:
    get_metrics_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_metrics_mode(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);
  {
    try {
      result = (Ogre::GuiMetricsMode)((Ogre::OverlayElement const *)arg1)->getMetricsMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_horizontal_alignment

  call-seq:
    set_horizontal_alignment(GuiHorizontalAlignment gha)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_horizontal_alignment(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);
  {
    try {
      (arg1)->setHorizontalAlignment(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_horizontal_alignment

  call-seq:
    get_horizontal_alignment -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_horizontal_alignment(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);
  {
    try {
      result = (Ogre::GuiHorizontalAlignment)((Ogre::OverlayElement const *)arg1)->getHorizontalAlignment();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_vertical_alignment

  call-seq:
    set_vertical_alignment(GuiVerticalAlignment gva)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_vertical_alignment(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);
  {
    try {
      (arg1)->setVerticalAlignment(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_vertical_alignment

  call-seq:
    get_vertical_alignment -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_vertical_alignment(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);
  {
    try {
      result = (Ogre::GuiVerticalAlignment)((Ogre::OverlayElement const *)arg1)->getVerticalAlignment();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.contains

  call-seq:
    contains(Real x, Real y) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::OverlayElement const *)arg1)->contains(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.find_element_at

  call-seq:
    find_element_at(Real x, Real y) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_find_element_at(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);
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->findElementAt(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.is_container

  call-seq:
    is_container -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_is_container(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);
  {
    try {
      result = (bool)((Ogre::OverlayElement const *)arg1)->isContainer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.is_key_enabled

  call-seq:
    is_key_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_is_key_enabled(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);
  {
    try {
      result = (bool)((Ogre::OverlayElement const *)arg1)->isKeyEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.is_cloneable

  call-seq:
    is_cloneable -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_is_cloneable(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);
  {
    try {
      result = (bool)((Ogre::OverlayElement const *)arg1)->isCloneable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.set_cloneable

  call-seq:
    set_cloneable(bool c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_set_cloneable(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);
  {
    try {
      (arg1)->setCloneable(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_parent

  call-seq:
    get_parent -> OverlayContainer

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_parent(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);
  {
    try {
      result = (Ogre::OverlayContainer *)(arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement._set_parent

  call-seq:
    _set_parent(OverlayContainer parent)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement__set_parent(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);
  {
    try {
      (arg1)->_setParent(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_zorder

  call-seq:
    get_zorder -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_zorder(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::OverlayElement const *)arg1)->getZOrder();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera cam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_lights

  call-seq:
    get_lights -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_lights(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::OverlayElement const *)arg1)->getLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.copy_from_template

  call-seq:
    copy_from_template(OverlayElement templateOverlay)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_copy_from_template(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);
  {
    try {
      (arg1)->copyFromTemplate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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;
  }
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->clone((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.get_source_template

  call-seq:
    get_source_template -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElement_get_source_template(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);
  {
    try {
      result = (Ogre::OverlayElement *)((Ogre::OverlayElement const *)arg1)->getSourceTemplate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::OverlayContainer < Ogre::Ogre::OverlayElement

  Proxy of C++ Ogre::OverlayContainer class


*/
swig_class SwigClassOverlayContainer;

SWIGINTERN void
free_Ogre_OverlayContainer(Ogre::OverlayContainer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::OverlayContainer.add_child

  call-seq:
    add_child(OverlayElement elem)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer_add_child(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);
  {
    try {
      (arg1)->addChild(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.add_child_impl

  call-seq:
    add_child_impl(OverlayElement elem)
    add_child_impl(OverlayContainer cont)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer_add_child_impl__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);
  {
    try {
      (arg1)->addChildImpl(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_add_child_impl__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);
  {
    try {
      (arg1)->addChildImpl(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayContainer_add_child_impl(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_add_child_impl__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_add_child_impl__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "OverlayContainer.add_child_impl", 
    "    void OverlayContainer.add_child_impl(Ogre::OverlayElement *elem)\n"
    "    void OverlayContainer.add_child_impl(Ogre::OverlayContainer *cont)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.remove_child

  call-seq:
    remove_child(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer_remove_child(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;
  }
  {
    try {
      (arg1)->removeChild((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.get_child

  call-seq:
    get_child(String name) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer_get_child(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;
  }
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->getChild((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.initialise

  call-seq:
    initialise

An instance method.

*/
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);
  {
    try {
      (arg1)->initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer._add_child

  call-seq:
    _add_child(OverlayElement elem)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer__add_child(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);
  {
    try {
      (arg1)->_addChild(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer._remove_child

  call-seq:
    _remove_child(OverlayElement elem)
    _remove_child(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer__remove_child__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);
  {
    try {
      (arg1)->_removeChild(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer__remove_child__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;
  }
  {
    try {
      (arg1)->_removeChild((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayContainer__remove_child(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__remove_child__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__remove_child__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "OverlayContainer._remove_child", 
    "    void OverlayContainer._remove_child(Ogre::OverlayElement *elem)\n"
    "    void OverlayContainer._remove_child(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.get_child_iterator

  call-seq:
    get_child_iterator -> ChildIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer_get_child_iterator(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);
  {
    try {
      result = (arg1)->getChildIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::OverlayContainer.get_child_container_iterator

  call-seq:
    get_child_container_iterator -> ChildContainerIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer_get_child_container_iterator(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);
  {
    try {
      result = (arg1)->getChildContainerIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::OverlayContainer._positions_out_of_date

  call-seq:
    _positions_out_of_date

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer__positions_out_of_date(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);
  {
    try {
      (arg1)->_positionsOutOfDate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer._update

  call-seq:
    _update

An instance method.

*/
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);
  {
    try {
      (arg1)->_update();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer._notify_zorder

  call-seq:
    _notify_zorder(ushort newZOrder) -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer__notify_zorder(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);
  {
    try {
      result = (Ogre::ushort)(arg1)->_notifyZOrder(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer._notify_viewport

  call-seq:
    _notify_viewport

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer__notify_viewport(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);
  {
    try {
      (arg1)->_notifyViewport();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer._notify_world_transforms

  call-seq:
    _notify_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer__notify_world_transforms(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);
  {
    try {
      (arg1)->_notifyWorldTransforms((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer._notify_parent

  call-seq:
    _notify_parent(OverlayContainer parent, Overlay overlay)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer__notify_parent(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);
  {
    try {
      (arg1)->_notifyParent(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.is_container

  call-seq:
    is_container -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer_is_container(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);
  {
    try {
      result = (bool)((Ogre::OverlayContainer const *)arg1)->isContainer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.is_children_process_events

  call-seq:
    is_children_process_events -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer_is_children_process_events(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);
  {
    try {
      result = (bool)((Ogre::OverlayContainer const *)arg1)->isChildrenProcessEvents();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.set_children_process_events

  call-seq:
    set_children_process_events(bool val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer_set_children_process_events(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);
  {
    try {
      (arg1)->setChildrenProcessEvents(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.find_element_at

  call-seq:
    find_element_at(Real x, Real y) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer_find_element_at(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);
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->findElementAt(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.copy_from_template

  call-seq:
    copy_from_template(OverlayElement templateOverlay)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayContainer_copy_from_template(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);
  {
    try {
      (arg1)->copyFromTemplate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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;
  }
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->clone((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.each_child

  call-seq:
    each_child

An instance method.

*/
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);
  {
    try {
      Ogre_OverlayContainer_each_child(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.each_child_container

  call-seq:
    each_child_container

An instance method.

*/
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);
  {
    try {
      Ogre_OverlayContainer_each_child_container(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.cast

  call-seq:
    cast(VALUE value) -> OverlayContainer

A class method.

*/
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];
  {
    try {
      result = (Ogre::OverlayContainer *)Ogre_OverlayContainer_cast(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PanelOverlayElement < Ogre::Ogre::OverlayContainer

  Proxy of C++ Ogre::PanelOverlayElement class


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


/*
  Document-method: Ogre::PanelOverlayElement.new

  call-seq:
    PanelOverlayElement.new(String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PanelOverlayElement *)new Ogre::PanelOverlayElement((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::PanelOverlayElement.initialise

  call-seq:
    initialise

An instance method.

*/
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);
  {
    try {
      (arg1)->initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElement.set_tiling

  call-seq:
    set_tiling(Real x, Real y, ushort layer=0)
    set_tiling(Real x, Real y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElement_set_tiling__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);
  {
    try {
      (arg1)->setTiling(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_set_tiling__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);
  {
    try {
      (arg1)->setTiling(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PanelOverlayElement_set_tiling(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_set_tiling__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_set_tiling__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "PanelOverlayElement.set_tiling", 
    "    void PanelOverlayElement.set_tiling(Ogre::Real x, Ogre::Real y, Ogre::ushort layer)\n"
    "    void PanelOverlayElement.set_tiling(Ogre::Real x, Ogre::Real y)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElement.get_tile_x

  call-seq:
    get_tile_x(ushort layer=0) -> Real
    get_tile_x -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElement_get_tile_x__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);
  {
    try {
      result = (Ogre::Real)((Ogre::PanelOverlayElement const *)arg1)->getTileX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_get_tile_x__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);
  {
    try {
      result = (Ogre::Real)((Ogre::PanelOverlayElement const *)arg1)->getTileX();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PanelOverlayElement_get_tile_x(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_get_tile_x__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_get_tile_x__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PanelOverlayElement.get_tile_x", 
    "    Ogre::Real PanelOverlayElement.get_tile_x(Ogre::ushort layer)\n"
    "    Ogre::Real PanelOverlayElement.get_tile_x()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElement.get_tile_y

  call-seq:
    get_tile_y(ushort layer=0) -> Real
    get_tile_y -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElement_get_tile_y__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);
  {
    try {
      result = (Ogre::Real)((Ogre::PanelOverlayElement const *)arg1)->getTileY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_get_tile_y__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);
  {
    try {
      result = (Ogre::Real)((Ogre::PanelOverlayElement const *)arg1)->getTileY();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PanelOverlayElement_get_tile_y(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_get_tile_y__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_get_tile_y__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PanelOverlayElement.get_tile_y", 
    "    Ogre::Real PanelOverlayElement.get_tile_y(Ogre::ushort layer)\n"
    "    Ogre::Real PanelOverlayElement.get_tile_y()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElement.set_uv

  call-seq:
    set_uv(Real u1, Real v1, Real u2, Real v2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElement_set_uv(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);
  {
    try {
      (arg1)->setUV(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElement.get_uv

  call-seq:
    get_uv(Real u1, Real v1, Real u2, Real v2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElement_get_uv(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);
  {
    try {
      ((Ogre::PanelOverlayElement const *)arg1)->getUV(*arg2,*arg3,*arg4,*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElement.set_transparent

  call-seq:
    set_transparent(bool isTransparent)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElement_set_transparent(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);
  {
    try {
      (arg1)->setTransparent(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElement.is_transparent

  call-seq:
    is_transparent -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElement_is_transparent(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);
  {
    try {
      result = (bool)((Ogre::PanelOverlayElement const *)arg1)->isTransparent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElement.get_type_name

  call-seq:
    get_type_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElement_get_type_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::PanelOverlayElement const *)arg1)->getTypeName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElement.get_render_operation

  call-seq:
    get_render_operation(RenderOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElement_get_render_operation(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);
  {
    try {
      (arg1)->getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElement.set_material_name

  call-seq:
    set_material_name(String matName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElement_set_material_name(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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElement._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElement__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElement.cast

  call-seq:
    cast(VALUE value) -> PanelOverlayElement

A class method.

*/
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];
  {
    try {
      result = (Ogre::PanelOverlayElement *)Ogre_PanelOverlayElement_cast(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PanelOverlayElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::BorderPanelOverlayElement < Ogre::Ogre::PanelOverlayElement

  Proxy of C++ Ogre::BorderPanelOverlayElement class


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


/*
  Document-method: Ogre::BorderPanelOverlayElement.new

  call-seq:
    BorderPanelOverlayElement.new(String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::BorderPanelOverlayElement *)new Ogre::BorderPanelOverlayElement((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::BorderPanelOverlayElement.initialise

  call-seq:
    initialise

An instance method.

*/
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);
  {
    try {
      (arg1)->initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_type_name

  call-seq:
    get_type_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_type_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::BorderPanelOverlayElement const *)arg1)->getTypeName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.set_border_size

  call-seq:
    set_border_size(Real size)
    set_border_size(Real sides, Real topAndBottom)
    set_border_size(Real left, Real right, Real top, Real bottom)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_border_size__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);
  {
    try {
      (arg1)->setBorderSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_border_size__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);
  {
    try {
      (arg1)->setBorderSize(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_border_size__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);
  {
    try {
      (arg1)->setBorderSize(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BorderPanelOverlayElement_set_border_size(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_set_border_size__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_set_border_size__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_set_border_size__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "BorderPanelOverlayElement.set_border_size", 
    "    void BorderPanelOverlayElement.set_border_size(Ogre::Real size)\n"
    "    void BorderPanelOverlayElement.set_border_size(Ogre::Real sides, Ogre::Real topAndBottom)\n"
    "    void BorderPanelOverlayElement.set_border_size(Ogre::Real left, Ogre::Real right, Ogre::Real top, Ogre::Real bottom)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_left_border_size

  call-seq:
    get_left_border_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_left_border_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::BorderPanelOverlayElement const *)arg1)->getLeftBorderSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_right_border_size

  call-seq:
    get_right_border_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_right_border_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::BorderPanelOverlayElement const *)arg1)->getRightBorderSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_top_border_size

  call-seq:
    get_top_border_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_top_border_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::BorderPanelOverlayElement const *)arg1)->getTopBorderSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_bottom_border_size

  call-seq:
    get_bottom_border_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_bottom_border_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::BorderPanelOverlayElement const *)arg1)->getBottomBorderSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.set_left_border_uv

  call-seq:
    set_left_border_uv(Real u1, Real v1, Real u2, Real v2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_left_border_uv(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);
  {
    try {
      (arg1)->setLeftBorderUV(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.set_right_border_uv

  call-seq:
    set_right_border_uv(Real u1, Real v1, Real u2, Real v2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_right_border_uv(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);
  {
    try {
      (arg1)->setRightBorderUV(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.set_top_border_uv

  call-seq:
    set_top_border_uv(Real u1, Real v1, Real u2, Real v2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_top_border_uv(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);
  {
    try {
      (arg1)->setTopBorderUV(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.set_bottom_border_uv

  call-seq:
    set_bottom_border_uv(Real u1, Real v1, Real u2, Real v2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_bottom_border_uv(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);
  {
    try {
      (arg1)->setBottomBorderUV(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.set_top_left_border_uv

  call-seq:
    set_top_left_border_uv(Real u1, Real v1, Real u2, Real v2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_top_left_border_uv(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);
  {
    try {
      (arg1)->setTopLeftBorderUV(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.set_top_right_border_uv

  call-seq:
    set_top_right_border_uv(Real u1, Real v1, Real u2, Real v2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_top_right_border_uv(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);
  {
    try {
      (arg1)->setTopRightBorderUV(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.set_bottom_left_border_uv

  call-seq:
    set_bottom_left_border_uv(Real u1, Real v1, Real u2, Real v2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_bottom_left_border_uv(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);
  {
    try {
      (arg1)->setBottomLeftBorderUV(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.set_bottom_right_border_uv

  call-seq:
    set_bottom_right_border_uv(Real u1, Real v1, Real u2, Real v2)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_bottom_right_border_uv(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);
  {
    try {
      (arg1)->setBottomRightBorderUV(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_left_border_uvstring

  call-seq:
    get_left_border_uvstring -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_left_border_uvstring(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);
  {
    try {
      result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getLeftBorderUVString();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_right_border_uvstring

  call-seq:
    get_right_border_uvstring -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_right_border_uvstring(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);
  {
    try {
      result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getRightBorderUVString();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_top_border_uvstring

  call-seq:
    get_top_border_uvstring -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_top_border_uvstring(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);
  {
    try {
      result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getTopBorderUVString();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_bottom_border_uvstring

  call-seq:
    get_bottom_border_uvstring -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_bottom_border_uvstring(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);
  {
    try {
      result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getBottomBorderUVString();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_top_left_border_uvstring

  call-seq:
    get_top_left_border_uvstring -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_top_left_border_uvstring(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);
  {
    try {
      result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getTopLeftBorderUVString();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_top_right_border_uvstring

  call-seq:
    get_top_right_border_uvstring -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_top_right_border_uvstring(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);
  {
    try {
      result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getTopRightBorderUVString();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_bottom_left_border_uvstring

  call-seq:
    get_bottom_left_border_uvstring -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_bottom_left_border_uvstring(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);
  {
    try {
      result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getBottomLeftBorderUVString();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_bottom_right_border_uvstring

  call-seq:
    get_bottom_right_border_uvstring -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_bottom_right_border_uvstring(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);
  {
    try {
      result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getBottomRightBorderUVString();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.set_border_material_name

  call-seq:
    set_border_material_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_border_material_name(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;
  }
  {
    try {
      (arg1)->setBorderMaterialName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.get_border_material_name

  call-seq:
    get_border_material_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_get_border_material_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::BorderPanelOverlayElement const *)arg1)->getBorderMaterialName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BorderPanelOverlayElement_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BorderPanelOverlayElement.visit_renderables", 
    "    void BorderPanelOverlayElement.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void BorderPanelOverlayElement.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.set_metrics_mode

  call-seq:
    set_metrics_mode(GuiMetricsMode gmm)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_set_metrics_mode(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);
  {
    try {
      (arg1)->setMetricsMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement._update

  call-seq:
    _update

An instance method.

*/
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);
  {
    try {
      (arg1)->_update();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElement.cast

  call-seq:
    cast(VALUE value) -> BorderPanelOverlayElement

A class method.

*/
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];
  {
    try {
      result = (Ogre::BorderPanelOverlayElement *)Ogre_BorderPanelOverlayElement_cast(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BorderPanelOverlayElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::BorderRenderable < Ogre::Ogre::Renderable

  Proxy of C++ Ogre::BorderRenderable class


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


/*
  Document-method: Ogre::BorderRenderable.new

  call-seq:
    BorderRenderable.new(BorderPanelOverlayElement parent)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::BorderRenderable *)new Ogre::BorderRenderable(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderRenderable.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderRenderable_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::BorderRenderable const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderRenderable.get_render_operation

  call-seq:
    get_render_operation(RenderOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderRenderable_get_render_operation(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);
  {
    try {
      (arg1)->getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderRenderable.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderRenderable_get_world_transforms(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);
  {
    try {
      ((Ogre::BorderRenderable const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderRenderable.get_num_world_transforms

  call-seq:
    get_num_world_transforms -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderRenderable_get_num_world_transforms(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);
  {
    try {
      result = (unsigned short)((Ogre::BorderRenderable const *)arg1)->getNumWorldTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderRenderable.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera cam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderRenderable_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::BorderRenderable const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderRenderable.get_lights

  call-seq:
    get_lights -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderRenderable_get_lights(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::BorderRenderable const *)arg1)->getLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BorderRenderable.get_polygon_mode_overrideable

  call-seq:
    get_polygon_mode_overrideable -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderRenderable_get_polygon_mode_overrideable(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);
  {
    try {
      result = (bool)((Ogre::BorderRenderable const *)arg1)->getPolygonModeOverrideable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_BorderRenderable(Ogre::BorderRenderable *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::Frustum < Ogre::Ogre::MovableObject, Ogre::Ogre::Renderable

  Proxy of C++ Ogre::Frustum class


*/
swig_class SwigClassFrustum;


/*
  Document-method: Ogre::Frustum.new

  call-seq:
    Frustum.new(String name=BLANK)
    Frustum.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Frustum *)new Ogre::Frustum((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Frustum *)new Ogre::Frustum();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::Frustum.set_fovy

  call-seq:
    set_fovy(Radian fovy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_fovy(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);
  {
    try {
      (arg1)->setFOVy((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_fovy

  call-seq:
    get_fovy -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_fovy(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);
  {
    try {
      result = (Ogre::Radian *) &((Ogre::Frustum const *)arg1)->getFOVy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_near_clip_distance

  call-seq:
    set_near_clip_distance(Real nearDist)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_near_clip_distance(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);
  {
    try {
      (arg1)->setNearClipDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_near_clip_distance

  call-seq:
    get_near_clip_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_near_clip_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getNearClipDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_far_clip_distance

  call-seq:
    set_far_clip_distance(Real farDist)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_far_clip_distance(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);
  {
    try {
      (arg1)->setFarClipDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_far_clip_distance

  call-seq:
    get_far_clip_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_far_clip_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getFarClipDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_aspect_ratio

  call-seq:
    set_aspect_ratio(Real ratio)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_aspect_ratio(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);
  {
    try {
      (arg1)->setAspectRatio(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_aspect_ratio

  call-seq:
    get_aspect_ratio -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_aspect_ratio(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getAspectRatio();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_frustum_offset

  call-seq:
    set_frustum_offset(Vector2 offset)
    set_frustum_offset(Real horizontal=0.0, Real vertical=0.0)
    set_frustum_offset(Real horizontal=0.0)
    set_frustum_offset

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_frustum_offset__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);
  {
    try {
      (arg1)->setFrustumOffset((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_set_frustum_offset__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);
  {
    try {
      (arg1)->setFrustumOffset(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_set_frustum_offset__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);
  {
    try {
      (arg1)->setFrustumOffset(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_set_frustum_offset__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);
  {
    try {
      (arg1)->setFrustumOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_set_frustum_offset(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_set_frustum_offset__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_set_frustum_offset__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_set_frustum_offset__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_set_frustum_offset__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Frustum.set_frustum_offset", 
    "    void Frustum.set_frustum_offset(Ogre::Vector2 const &offset)\n"
    "    void Frustum.set_frustum_offset(Ogre::Real horizontal, Ogre::Real vertical)\n"
    "    void Frustum.set_frustum_offset(Ogre::Real horizontal)\n"
    "    void Frustum.set_frustum_offset()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_frustum_offset

  call-seq:
    get_frustum_offset -> Vector2

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_frustum_offset(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);
  {
    try {
      result = (Ogre::Vector2 *) &((Ogre::Frustum const *)arg1)->getFrustumOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_focal_length

  call-seq:
    set_focal_length(Real focalLength=1.0)
    set_focal_length

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_focal_length__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);
  {
    try {
      (arg1)->setFocalLength(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_set_focal_length__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);
  {
    try {
      (arg1)->setFocalLength();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_set_focal_length(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_set_focal_length__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_set_focal_length__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Frustum.set_focal_length", 
    "    void Frustum.set_focal_length(Ogre::Real focalLength)\n"
    "    void Frustum.set_focal_length()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_focal_length

  call-seq:
    get_focal_length -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_focal_length(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getFocalLength();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_frustum_extents

  call-seq:
    set_frustum_extents(Real left, Real right, Real top, Real bottom)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_frustum_extents(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);
  {
    try {
      (arg1)->setFrustumExtents(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.reset_frustum_extents

  call-seq:
    reset_frustum_extents

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_reset_frustum_extents(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);
  {
    try {
      (arg1)->resetFrustumExtents();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_frustum_extents

  call-seq:
    get_frustum_extents(Real outleft, Real outright, Real outtop, Real outbottom)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_frustum_extents(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);
  {
    try {
      ((Ogre::Frustum const *)arg1)->getFrustumExtents(*arg2,*arg3,*arg4,*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_projection_matrix_rs

  call-seq:
    get_projection_matrix_rs -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_projection_matrix_rs(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::Frustum const *)arg1)->getProjectionMatrixRS();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_projection_matrix_with_rsdepth

  call-seq:
    get_projection_matrix_with_rsdepth -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_projection_matrix_with_rsdepth(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::Frustum const *)arg1)->getProjectionMatrixWithRSDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_projection_matrix

  call-seq:
    get_projection_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_projection_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::Frustum const *)arg1)->getProjectionMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_view_matrix

  call-seq:
    get_view_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_view_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::Frustum const *)arg1)->getViewMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.calc_view_matrix_relative

  call-seq:
    calc_view_matrix_relative(Vector3 relPos, Matrix4 matToUpdate)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_calc_view_matrix_relative(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);
  {
    try {
      ((Ogre::Frustum const *)arg1)->calcViewMatrixRelative((Ogre::Vector3 const &)*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_custom_view_matrix

  call-seq:
    set_custom_view_matrix(bool enable, Matrix4 viewMatrix=IDENTITY)
    set_custom_view_matrix(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_custom_view_matrix__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);
  {
    try {
      (arg1)->setCustomViewMatrix(arg2,(Ogre::Matrix4 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_set_custom_view_matrix__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);
  {
    try {
      (arg1)->setCustomViewMatrix(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_set_custom_view_matrix(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_set_custom_view_matrix__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_set_custom_view_matrix__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Frustum.set_custom_view_matrix", 
    "    void Frustum.set_custom_view_matrix(bool enable, Ogre::Matrix4 const &viewMatrix)\n"
    "    void Frustum.set_custom_view_matrix(bool enable)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.is_custom_view_matrix_enabled

  call-seq:
    is_custom_view_matrix_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_is_custom_view_matrix_enabled(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);
  {
    try {
      result = (bool)((Ogre::Frustum const *)arg1)->isCustomViewMatrixEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_custom_projection_matrix

  call-seq:
    set_custom_projection_matrix(bool enable, Matrix4 projectionMatrix=IDENTITY)
    set_custom_projection_matrix(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_custom_projection_matrix__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);
  {
    try {
      (arg1)->setCustomProjectionMatrix(arg2,(Ogre::Matrix4 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_set_custom_projection_matrix__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);
  {
    try {
      (arg1)->setCustomProjectionMatrix(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_set_custom_projection_matrix(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_set_custom_projection_matrix__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_set_custom_projection_matrix__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Frustum.set_custom_projection_matrix", 
    "    void Frustum.set_custom_projection_matrix(bool enable, Ogre::Matrix4 const &projectionMatrix)\n"
    "    void Frustum.set_custom_projection_matrix(bool enable)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.is_custom_projection_matrix_enabled

  call-seq:
    is_custom_projection_matrix_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_is_custom_projection_matrix_enabled(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);
  {
    try {
      result = (bool)((Ogre::Frustum const *)arg1)->isCustomProjectionMatrixEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_frustum_planes

  call-seq:
    get_frustum_planes -> Plane

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_frustum_planes(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);
  {
    try {
      result = (Ogre::Plane *)((Ogre::Frustum const *)arg1)->getFrustumPlanes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_frustum_plane

  call-seq:
    get_frustum_plane(unsigned short plane) -> Plane

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_frustum_plane(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);
  {
    try {
      result = (Ogre::Plane *) &((Ogre::Frustum const *)arg1)->getFrustumPlane(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.is_visible

  call-seq:
    is_visible(AxisAlignedBox bound, FrustumPlane culledBy=0) -> bool
    is_visible(AxisAlignedBox bound) -> bool
    is_visible(Sphere bound, FrustumPlane culledBy=0) -> bool
    is_visible(Sphere bound) -> bool
    is_visible(Vector3 vert, FrustumPlane culledBy=0) -> bool
    is_visible(Vector3 vert) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_is_visible__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);
  {
    try {
      result = (bool)((Ogre::Frustum const *)arg1)->isVisible((Ogre::AxisAlignedBox const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_is_visible__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);
  {
    try {
      result = (bool)((Ogre::Frustum const *)arg1)->isVisible((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_is_visible__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);
  {
    try {
      result = (bool)((Ogre::Frustum const *)arg1)->isVisible((Ogre::Sphere const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_is_visible__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);
  {
    try {
      result = (bool)((Ogre::Frustum const *)arg1)->isVisible((Ogre::Sphere const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_is_visible__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);
  {
    try {
      result = (bool)((Ogre::Frustum const *)arg1)->isVisible((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_is_visible__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);
  {
    try {
      result = (bool)((Ogre::Frustum const *)arg1)->isVisible((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_is_visible(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_is_visible__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_is_visible__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_is_visible__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_is_visible__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_is_visible__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_is_visible__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Frustum.is_visible", 
    "    bool Frustum.is_visible(Ogre::AxisAlignedBox const &bound, Ogre::FrustumPlane *culledBy)\n"
    "    bool Frustum.is_visible(Ogre::AxisAlignedBox const &bound)\n"
    "    bool Frustum.is_visible(Ogre::Sphere const &bound, Ogre::FrustumPlane *culledBy)\n"
    "    bool Frustum.is_visible(Ogre::Sphere const &bound)\n"
    "    bool Frustum.is_visible(Ogre::Vector3 const &vert, Ogre::FrustumPlane *culledBy)\n"
    "    bool Frustum.is_visible(Ogre::Vector3 const &vert)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_type_flags

  call-seq:
    get_type_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_type_flags(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::Frustum const *)arg1)->getTypeFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::Frustum const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Frustum const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum._notify_current_camera

  call-seq:
    _notify_current_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum__notify_current_camera(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);
  {
    try {
      (arg1)->_notifyCurrentCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::Frustum const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_render_operation

  call-seq:
    get_render_operation(RenderOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_render_operation(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);
  {
    try {
      (arg1)->getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_world_transforms(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);
  {
    try {
      ((Ogre::Frustum const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera cam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_lights

  call-seq:
    get_lights -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_lights(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::Frustum const *)arg1)->getLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_world_space_corners

  call-seq:
    get_world_space_corners -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_world_space_corners(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);
  {
    try {
      result = (Ogre::Vector3 *)((Ogre::Frustum const *)arg1)->getWorldSpaceCorners();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_projection_type

  call-seq:
    set_projection_type(ProjectionType pt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_projection_type(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);
  {
    try {
      (arg1)->setProjectionType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_projection_type

  call-seq:
    get_projection_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_projection_type(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);
  {
    try {
      result = (Ogre::ProjectionType)((Ogre::Frustum const *)arg1)->getProjectionType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_ortho_window

  call-seq:
    set_ortho_window(Real w, Real h)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_ortho_window(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);
  {
    try {
      (arg1)->setOrthoWindow(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_ortho_window_height

  call-seq:
    set_ortho_window_height(Real h)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_ortho_window_height(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);
  {
    try {
      (arg1)->setOrthoWindowHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_ortho_window_width

  call-seq:
    set_ortho_window_width(Real w)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_ortho_window_width(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);
  {
    try {
      (arg1)->setOrthoWindowWidth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_ortho_window_height

  call-seq:
    get_ortho_window_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_ortho_window_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getOrthoWindowHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_ortho_window_width

  call-seq:
    get_ortho_window_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_ortho_window_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getOrthoWindowWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.enable_reflection

  call-seq:
    enable_reflection(Plane p)
    enable_reflection(MovablePlane p)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_enable_reflection__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);
  {
    try {
      (arg1)->enableReflection((Ogre::Plane const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_enable_reflection__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);
  {
    try {
      (arg1)->enableReflection((Ogre::MovablePlane const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_enable_reflection(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_enable_reflection__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_enable_reflection__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Frustum.enable_reflection", 
    "    void Frustum.enable_reflection(Ogre::Plane const &p)\n"
    "    void Frustum.enable_reflection(Ogre::MovablePlane const *p)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.disable_reflection

  call-seq:
    disable_reflection

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_disable_reflection(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);
  {
    try {
      (arg1)->disableReflection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.is_reflected

  call-seq:
    is_reflected -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_is_reflected(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);
  {
    try {
      result = (bool)((Ogre::Frustum const *)arg1)->isReflected();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_reflection_matrix

  call-seq:
    get_reflection_matrix -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_reflection_matrix(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::Frustum const *)arg1)->getReflectionMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_reflection_plane

  call-seq:
    get_reflection_plane -> Plane

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_reflection_plane(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);
  {
    try {
      result = (Ogre::Plane *) &((Ogre::Frustum const *)arg1)->getReflectionPlane();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.project_sphere

  call-seq:
    project_sphere(Sphere sphere, Real left, Real top, Real right, Real bottom) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_project_sphere(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);
  {
    try {
      result = (bool)((Ogre::Frustum const *)arg1)->projectSphere((Ogre::Sphere const &)*arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.enable_custom_near_clip_plane

  call-seq:
    enable_custom_near_clip_plane(MovablePlane plane)
    enable_custom_near_clip_plane(Plane plane)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_enable_custom_near_clip_plane__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);
  {
    try {
      (arg1)->enableCustomNearClipPlane((Ogre::MovablePlane const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_enable_custom_near_clip_plane__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);
  {
    try {
      (arg1)->enableCustomNearClipPlane((Ogre::Plane const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_enable_custom_near_clip_plane(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_enable_custom_near_clip_plane__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_enable_custom_near_clip_plane__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Frustum.enable_custom_near_clip_plane", 
    "    void Frustum.enable_custom_near_clip_plane(Ogre::MovablePlane const *plane)\n"
    "    void Frustum.enable_custom_near_clip_plane(Ogre::Plane const &plane)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.disable_custom_near_clip_plane

  call-seq:
    disable_custom_near_clip_plane

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_disable_custom_near_clip_plane(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);
  {
    try {
      (arg1)->disableCustomNearClipPlane();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.is_custom_near_clip_plane_enabled

  call-seq:
    is_custom_near_clip_plane_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_is_custom_near_clip_plane_enabled(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);
  {
    try {
      result = (bool)((Ogre::Frustum const *)arg1)->isCustomNearClipPlaneEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Frustum.visit_renderables", 
    "    void Frustum.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void Frustum.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.INFINITE_FAR_PLANE_ADJUST

  call-seq:
    INFINITE_FAR_PLANE_ADJUST -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Frustum.Frustum_INFINITE_FAR_PLANE_ADJUST

  call-seq:
    Frustum_INFINITE_FAR_PLANE_ADJUST -> Real

Get value of attribute.

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



/*
  Document-method: Ogre::Frustum.get_position_for_view_update

  call-seq:
    get_position_for_view_update -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_position_for_view_update(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Frustum const *)arg1)->getPositionForViewUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_orientation_for_view_update

  call-seq:
    get_orientation_for_view_update -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_orientation_for_view_update(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);
  {
    try {
      result = (Ogre::Quaternion *) &((Ogre::Frustum const *)arg1)->getOrientationForViewUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_plane_bounded_volume

  call-seq:
    get_plane_bounded_volume -> PlaneBoundedVolume

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_plane_bounded_volume(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);
  {
    try {
      result = (arg1)->getPlaneBoundedVolume();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::PlaneBoundedVolume(static_cast< const Ogre::PlaneBoundedVolume& >(result))), SWIGTYPE_p_Ogre__PlaneBoundedVolume, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.set_orientation_mode

  call-seq:
    set_orientation_mode(OrientationMode orientationMode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_set_orientation_mode(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);
  {
    try {
      (arg1)->setOrientationMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Frustum.get_orientation_mode

  call-seq:
    get_orientation_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Frustum_get_orientation_mode(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);
  {
    try {
      result = (Ogre::OrientationMode)((Ogre::Frustum const *)arg1)->getOrientationMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Ray

  Proxy of C++ Ogre::Ray class


*/
swig_class SwigClassRay;


/*
  Document-method: Ogre::Ray.new

  call-seq:
    Ray.new
    Ray.new(Vector3 origin, Vector3 direction)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Ray *)new Ogre::Ray();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Ray *)new Ogre::Ray((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::Ray.set_origin

  call-seq:
    set_origin(Vector3 origin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Ray_set_origin(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);
  {
    try {
      (arg1)->setOrigin((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Ray.get_origin

  call-seq:
    get_origin -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Ray_get_origin(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Ray const *)arg1)->getOrigin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Ray.set_direction

  call-seq:
    set_direction(Vector3 dir)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Ray_set_direction(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);
  {
    try {
      (arg1)->setDirection((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Ray.get_direction

  call-seq:
    get_direction -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Ray_get_direction(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Ray const *)arg1)->getDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Ray.get_point

  call-seq:
    get_point(Real t) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Ray_get_point(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);
  {
    try {
      result = ((Ogre::Ray const *)arg1)->getPoint(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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::Ray.*

  call-seq:
    *(Real t) -> Vector3

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Ray const *)arg1)->operator *(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Ray.intersects

  call-seq:
    intersects(Plane p) -> std::pair<(bool,Ogre::Real)>
    intersects(PlaneBoundedVolume p) -> std::pair<(bool,Ogre::Real)>
    intersects(Sphere s) -> std::pair<(bool,Ogre::Real)>
    intersects(AxisAlignedBox box) -> std::pair<(bool,Ogre::Real)>

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Ray const *)arg1)->intersects((Ogre::Plane const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = ((Ogre::Ray const *)arg1)->intersects((Ogre::PlaneBoundedVolume const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = ((Ogre::Ray const *)arg1)->intersects((Ogre::Sphere const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = ((Ogre::Ray const *)arg1)->intersects((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
}


/*
  Document-class: Ogre::Camera < Ogre::Ogre::Frustum

  Proxy of C++ Ogre::Camera class


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


/*
  Document-method: Ogre::Camera.new

  call-seq:
    Camera.new(String name, SceneManager sm)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Camera *)new Ogre::Camera((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::Camera.add_listener

  call-seq:
    add_listener(Listener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_add_listener(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);
  {
    try {
      (arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.remove_listener

  call-seq:
    remove_listener(Listener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_remove_listener(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);
  {
    try {
      (arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_scene_manager

  call-seq:
    get_scene_manager -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_scene_manager(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);
  {
    try {
      result = (Ogre::SceneManager *)((Ogre::Camera const *)arg1)->getSceneManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.set_polygon_mode

  call-seq:
    set_polygon_mode(PolygonMode sd)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_polygon_mode(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);
  {
    try {
      (arg1)->setPolygonMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_polygon_mode

  call-seq:
    get_polygon_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_polygon_mode(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);
  {
    try {
      result = (Ogre::PolygonMode)((Ogre::Camera const *)arg1)->getPolygonMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.set_position

  call-seq:
    set_position(Real x, Real y, Real z)
    set_position(Vector3 vec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_position__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);
  {
    try {
      (arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_set_position__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);
  {
    try {
      (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_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_set_position__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_set_position__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Camera.set_position", 
    "    void Camera.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    void Camera.set_position(Ogre::Vector3 const &vec)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_position

  call-seq:
    get_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Camera const *)arg1)->getPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.move

  call-seq:
    move(Vector3 vec)

An instance method.

*/
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);
  {
    try {
      (arg1)->move((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.move_relative

  call-seq:
    move_relative(Vector3 vec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_move_relative(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);
  {
    try {
      (arg1)->moveRelative((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.set_direction

  call-seq:
    set_direction(Real x, Real y, Real z)
    set_direction(Vector3 vec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_direction__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);
  {
    try {
      (arg1)->setDirection(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_set_direction__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);
  {
    try {
      (arg1)->setDirection((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_set_direction(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_set_direction__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_set_direction__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Camera.set_direction", 
    "    void Camera.set_direction(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    void Camera.set_direction(Ogre::Vector3 const &vec)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_direction

  call-seq:
    get_direction -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_direction(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);
  {
    try {
      result = ((Ogre::Camera const *)arg1)->getDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_up

  call-seq:
    get_up -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_up(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);
  {
    try {
      result = ((Ogre::Camera const *)arg1)->getUp();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_right

  call-seq:
    get_right -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_right(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);
  {
    try {
      result = ((Ogre::Camera const *)arg1)->getRight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.look_at

  call-seq:
    look_at(Vector3 targetPoint)
    look_at(Real x, Real y, Real z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_look_at__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);
  {
    try {
      (arg1)->lookAt((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_look_at__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);
  {
    try {
      (arg1)->lookAt(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_look_at(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_look_at__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_look_at__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Camera.look_at", 
    "    void Camera.look_at(Ogre::Vector3 const &targetPoint)\n"
    "    void Camera.look_at(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Camera.roll

  call-seq:
    roll(Radian angle)

An instance method.

*/
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);
  {
    try {
      (arg1)->roll((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.yaw

  call-seq:
    yaw(Radian angle)

An instance method.

*/
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);
  {
    try {
      (arg1)->yaw((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.pitch

  call-seq:
    pitch(Radian angle)

An instance method.

*/
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);
  {
    try {
      (arg1)->pitch((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.rotate

  call-seq:
    rotate(Vector3 axis, Radian angle)
    rotate(Quaternion q)

An instance method.

*/
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);
  {
    try {
      (arg1)->rotate((Ogre::Vector3 const &)*arg2,(Ogre::Radian const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->rotate((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::Camera.set_fixed_yaw_axis

  call-seq:
    set_fixed_yaw_axis(bool useFixed, Vector3 fixedAxis=UNIT_Y)
    set_fixed_yaw_axis(bool useFixed)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_fixed_yaw_axis__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);
  {
    try {
      (arg1)->setFixedYawAxis(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_set_fixed_yaw_axis__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);
  {
    try {
      (arg1)->setFixedYawAxis(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_set_fixed_yaw_axis(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_set_fixed_yaw_axis__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_set_fixed_yaw_axis__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Camera.set_fixed_yaw_axis", 
    "    void Camera.set_fixed_yaw_axis(bool useFixed, Ogre::Vector3 const &fixedAxis)\n"
    "    void Camera.set_fixed_yaw_axis(bool useFixed)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_orientation

  call-seq:
    get_orientation -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_orientation(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);
  {
    try {
      result = (Ogre::Quaternion *) &((Ogre::Camera const *)arg1)->getOrientation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.set_orientation

  call-seq:
    set_orientation(Quaternion q)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_orientation(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);
  {
    try {
      (arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera._render_scene

  call-seq:
    _render_scene(Viewport vp, bool includeOverlays)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera__render_scene(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);
  {
    try {
      (arg1)->_renderScene(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera._notify_rendered_faces

  call-seq:
    _notify_rendered_faces(unsigned int numfaces)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera__notify_rendered_faces(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);
  {
    try {
      (arg1)->_notifyRenderedFaces(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera._notify_rendered_batches

  call-seq:
    _notify_rendered_batches(unsigned int numbatches)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera__notify_rendered_batches(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);
  {
    try {
      (arg1)->_notifyRenderedBatches(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera._get_num_rendered_faces

  call-seq:
    _get_num_rendered_faces -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera__get_num_rendered_faces(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);
  {
    try {
      result = (unsigned int)((Ogre::Camera const *)arg1)->_getNumRenderedFaces();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera._get_num_rendered_batches

  call-seq:
    _get_num_rendered_batches -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera__get_num_rendered_batches(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);
  {
    try {
      result = (unsigned int)((Ogre::Camera const *)arg1)->_getNumRenderedBatches();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_derived_orientation

  call-seq:
    get_derived_orientation -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_derived_orientation(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);
  {
    try {
      result = (Ogre::Quaternion *) &((Ogre::Camera const *)arg1)->getDerivedOrientation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_derived_position

  call-seq:
    get_derived_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_derived_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Camera const *)arg1)->getDerivedPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_derived_direction

  call-seq:
    get_derived_direction -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_derived_direction(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);
  {
    try {
      result = ((Ogre::Camera const *)arg1)->getDerivedDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_derived_up

  call-seq:
    get_derived_up -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_derived_up(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);
  {
    try {
      result = ((Ogre::Camera const *)arg1)->getDerivedUp();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_derived_right

  call-seq:
    get_derived_right -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_derived_right(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);
  {
    try {
      result = ((Ogre::Camera const *)arg1)->getDerivedRight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_real_orientation

  call-seq:
    get_real_orientation -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_real_orientation(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);
  {
    try {
      result = (Ogre::Quaternion *) &((Ogre::Camera const *)arg1)->getRealOrientation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_real_position

  call-seq:
    get_real_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_real_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Camera const *)arg1)->getRealPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_real_direction

  call-seq:
    get_real_direction -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_real_direction(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);
  {
    try {
      result = ((Ogre::Camera const *)arg1)->getRealDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_real_up

  call-seq:
    get_real_up -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_real_up(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);
  {
    try {
      result = ((Ogre::Camera const *)arg1)->getRealUp();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_real_right

  call-seq:
    get_real_right -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_real_right(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);
  {
    try {
      result = ((Ogre::Camera const *)arg1)->getRealRight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 mat)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_world_transforms(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);
  {
    try {
      ((Ogre::Camera const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Camera const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.set_auto_tracking

  call-seq:
    set_auto_tracking(bool enabled, SceneNode target=0, Vector3 offset=)
    set_auto_tracking(bool enabled, SceneNode target=0)
    set_auto_tracking(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_auto_tracking__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);
  {
    try {
      (arg1)->setAutoTracking(arg2,arg3,(Ogre::Vector3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_set_auto_tracking__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);
  {
    try {
      (arg1)->setAutoTracking(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_set_auto_tracking__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);
  {
    try {
      (arg1)->setAutoTracking(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_set_auto_tracking(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_set_auto_tracking__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_set_auto_tracking__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_set_auto_tracking__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Camera.set_auto_tracking", 
    "    void Camera.set_auto_tracking(bool enabled, Ogre::SceneNode *const target, Ogre::Vector3 const &offset)\n"
    "    void Camera.set_auto_tracking(bool enabled, Ogre::SceneNode *const target)\n"
    "    void Camera.set_auto_tracking(bool enabled)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Camera.set_lod_bias

  call-seq:
    set_lod_bias(Real factor=1.0)
    set_lod_bias

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_lod_bias__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);
  {
    try {
      (arg1)->setLodBias(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_set_lod_bias__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);
  {
    try {
      (arg1)->setLodBias();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_set_lod_bias(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_set_lod_bias__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_set_lod_bias__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Camera.set_lod_bias", 
    "    void Camera.set_lod_bias(Ogre::Real factor)\n"
    "    void Camera.set_lod_bias()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_lod_bias

  call-seq:
    get_lod_bias -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_lod_bias(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Camera const *)arg1)->getLodBias();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.set_lod_camera

  call-seq:
    set_lod_camera(Camera lodCam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_lod_camera(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);
  {
    try {
      (arg1)->setLodCamera((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_lod_camera

  call-seq:
    get_lod_camera -> Camera

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_lod_camera(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);
  {
    try {
      result = (Ogre::Camera *)((Ogre::Camera const *)arg1)->getLodCamera();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_camera_to_viewport_ray

  call-seq:
    get_camera_to_viewport_ray(Real screenx, Real screeny) -> Ray
    get_camera_to_viewport_ray(Real screenx, Real screeny, Ray outRay)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_camera_to_viewport_ray__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);
  {
    try {
      result = ((Ogre::Camera const *)arg1)->getCameraToViewportRay(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Ray(static_cast< const Ogre::Ray& >(result))), SWIGTYPE_p_Ogre__Ray, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_get_camera_to_viewport_ray__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);
  {
    try {
      ((Ogre::Camera const *)arg1)->getCameraToViewportRay(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_get_camera_to_viewport_ray(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_get_camera_to_viewport_ray__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_get_camera_to_viewport_ray__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Camera.get_camera_to_viewport_ray", 
    "    void Camera.get_camera_to_viewport_ray(Ogre::Real screenx, Ogre::Real screeny)\n"
    "    void Camera.get_camera_to_viewport_ray(Ogre::Real screenx, Ogre::Real screeny, Ogre::Ray *outRay)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_camera_to_viewport_box_volume

  call-seq:
    get_camera_to_viewport_box_volume(Real screenLeft, Real screenTop, Real screenRight, 
    Real screenBottom, bool includeFarPlane=false) -> PlaneBoundedVolume
    get_camera_to_viewport_box_volume(Real screenLeft, Real screenTop, Real screenRight, 
    Real screenBottom) -> PlaneBoundedVolume
    get_camera_to_viewport_box_volume(Real screenLeft, Real screenTop, Real screenRight, 
    Real screenBottom, PlaneBoundedVolume outVolume, 
    bool includeFarPlane=false)
    get_camera_to_viewport_box_volume(Real screenLeft, Real screenTop, Real screenRight, 
    Real screenBottom, PlaneBoundedVolume outVolume)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_camera_to_viewport_box_volume__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);
  {
    try {
      result = (arg1)->getCameraToViewportBoxVolume(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::PlaneBoundedVolume(static_cast< const Ogre::PlaneBoundedVolume& >(result))), SWIGTYPE_p_Ogre__PlaneBoundedVolume, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_get_camera_to_viewport_box_volume__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);
  {
    try {
      result = (arg1)->getCameraToViewportBoxVolume(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_get_camera_to_viewport_box_volume__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);
  {
    try {
      (arg1)->getCameraToViewportBoxVolume(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_get_camera_to_viewport_box_volume__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);
  {
    try {
      (arg1)->getCameraToViewportBoxVolume(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_get_camera_to_viewport_box_volume(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_get_camera_to_viewport_box_volume__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_get_camera_to_viewport_box_volume__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_get_camera_to_viewport_box_volume__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_get_camera_to_viewport_box_volume__SWIG_2(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Camera.get_camera_to_viewport_box_volume", 
    "    void Camera.get_camera_to_viewport_box_volume(Ogre::Real screenLeft, Ogre::Real screenTop, Ogre::Real screenRight, Ogre::Real screenBottom, bool includeFarPlane)\n"
    "    void Camera.get_camera_to_viewport_box_volume(Ogre::Real screenLeft, Ogre::Real screenTop, Ogre::Real screenRight, Ogre::Real screenBottom)\n"
    "    void Camera.get_camera_to_viewport_box_volume(Ogre::Real screenLeft, Ogre::Real screenTop, Ogre::Real screenRight, Ogre::Real screenBottom, Ogre::PlaneBoundedVolume *outVolume, bool includeFarPlane)\n"
    "    void Camera.get_camera_to_viewport_box_volume(Ogre::Real screenLeft, Ogre::Real screenTop, Ogre::Real screenRight, Ogre::Real screenBottom, Ogre::PlaneBoundedVolume *outVolume)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Camera._get_lod_bias_inverse

  call-seq:
    _get_lod_bias_inverse -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera__get_lod_bias_inverse(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Camera const *)arg1)->_getLodBiasInverse();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera._auto_track

  call-seq:
    _auto_track

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera__auto_track(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);
  {
    try {
      (arg1)->_autoTrack();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.set_window

  call-seq:
    set_window(Real Left, Real Top, Real Right, Real Bottom)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_window(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);
  {
    try {
      (arg1)->setWindow(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.reset_window

  call-seq:
    reset_window

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_reset_window(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);
  {
    try {
      (arg1)->resetWindow();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.is_window_set

  call-seq:
    is_window_set -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_is_window_set(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);
  {
    try {
      result = (bool)((Ogre::Camera const *)arg1)->isWindowSet();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_window_planes

  call-seq:
    get_window_planes -> Ogre::vector<(Ogre::Plane,Ogre::STLAllocator<(Ogre::Plane,Ogre::GeneralAllocPolicy)>)>::type

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_window_planes(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);
  {
    try {
      result = (Ogre::vector< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type *) &((Ogre::Camera const *)arg1)->getWindowPlanes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Camera const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_auto_track_target

  call-seq:
    get_auto_track_target -> SceneNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_auto_track_target(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);
  {
    try {
      result = (Ogre::SceneNode *)((Ogre::Camera const *)arg1)->getAutoTrackTarget();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_auto_track_offset

  call-seq:
    get_auto_track_offset -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_auto_track_offset(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Camera const *)arg1)->getAutoTrackOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_viewport

  call-seq:
    get_viewport -> Viewport

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_viewport(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);
  {
    try {
      result = (Ogre::Viewport *)((Ogre::Camera const *)arg1)->getViewport();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera._notify_viewport

  call-seq:
    _notify_viewport(Viewport viewport)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera__notify_viewport(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);
  {
    try {
      (arg1)->_notifyViewport(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.set_auto_aspect_ratio

  call-seq:
    set_auto_aspect_ratio(bool autoratio)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_auto_aspect_ratio(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);
  {
    try {
      (arg1)->setAutoAspectRatio(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_auto_aspect_ratio

  call-seq:
    get_auto_aspect_ratio -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_auto_aspect_ratio(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);
  {
    try {
      result = (bool)((Ogre::Camera const *)arg1)->getAutoAspectRatio();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.set_culling_frustum

  call-seq:
    set_culling_frustum(Frustum frustum)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_culling_frustum(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);
  {
    try {
      (arg1)->setCullingFrustum(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_culling_frustum

  call-seq:
    get_culling_frustum -> Frustum

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_culling_frustum(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);
  {
    try {
      result = (Ogre::Frustum *)((Ogre::Camera const *)arg1)->getCullingFrustum();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Frustum, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.forward_intersect

  call-seq:
    forward_intersect(Plane worldPlane, Ogre::vector<(Ogre::Vector4,Ogre::STLAllocator<(Ogre::Vector4,Ogre::GeneralAllocPolicy)>)>::type intersect3d)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_forward_intersect(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);
  {
    try {
      ((Ogre::Camera const *)arg1)->forwardIntersect((Ogre::Plane const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.is_visible

  call-seq:
    is_visible(AxisAlignedBox bound, FrustumPlane culledBy=0) -> bool
    is_visible(AxisAlignedBox bound) -> bool
    is_visible(Sphere bound, FrustumPlane culledBy=0) -> bool
    is_visible(Sphere bound) -> bool
    is_visible(Vector3 vert, FrustumPlane culledBy=0) -> bool
    is_visible(Vector3 vert) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_is_visible__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);
  {
    try {
      result = (bool)((Ogre::Camera const *)arg1)->isVisible((Ogre::AxisAlignedBox const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_is_visible__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);
  {
    try {
      result = (bool)((Ogre::Camera const *)arg1)->isVisible((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_is_visible__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);
  {
    try {
      result = (bool)((Ogre::Camera const *)arg1)->isVisible((Ogre::Sphere const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_is_visible__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);
  {
    try {
      result = (bool)((Ogre::Camera const *)arg1)->isVisible((Ogre::Sphere const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_is_visible__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);
  {
    try {
      result = (bool)((Ogre::Camera const *)arg1)->isVisible((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_is_visible__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);
  {
    try {
      result = (bool)((Ogre::Camera const *)arg1)->isVisible((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_is_visible(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_is_visible__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_is_visible__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_is_visible__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_is_visible__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_is_visible__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_is_visible__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Camera.is_visible", 
    "    bool Camera.is_visible(Ogre::AxisAlignedBox const &bound, Ogre::FrustumPlane *culledBy)\n"
    "    bool Camera.is_visible(Ogre::AxisAlignedBox const &bound)\n"
    "    bool Camera.is_visible(Ogre::Sphere const &bound, Ogre::FrustumPlane *culledBy)\n"
    "    bool Camera.is_visible(Ogre::Sphere const &bound)\n"
    "    bool Camera.is_visible(Ogre::Vector3 const &vert, Ogre::FrustumPlane *culledBy)\n"
    "    bool Camera.is_visible(Ogre::Vector3 const &vert)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_world_space_corners

  call-seq:
    get_world_space_corners -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_world_space_corners(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);
  {
    try {
      result = (Ogre::Vector3 *)((Ogre::Camera const *)arg1)->getWorldSpaceCorners();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_frustum_plane

  call-seq:
    get_frustum_plane(unsigned short plane) -> Plane

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_frustum_plane(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);
  {
    try {
      result = (Ogre::Plane *) &((Ogre::Camera const *)arg1)->getFrustumPlane(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.project_sphere

  call-seq:
    project_sphere(Sphere sphere, Real left, Real top, Real right, Real bottom) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_project_sphere(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);
  {
    try {
      result = (bool)((Ogre::Camera const *)arg1)->projectSphere((Ogre::Sphere const &)*arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_near_clip_distance

  call-seq:
    get_near_clip_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_near_clip_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Camera const *)arg1)->getNearClipDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_far_clip_distance

  call-seq:
    get_far_clip_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_far_clip_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Camera const *)arg1)->getFarClipDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_view_matrix

  call-seq:
    get_view_matrix -> Matrix4
    get_view_matrix(bool ownFrustumOnly) -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_view_matrix__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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::Camera const *)arg1)->getViewMatrix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_get_view_matrix__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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::Camera const *)arg1)->getViewMatrix(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_get_view_matrix(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_get_view_matrix__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_get_view_matrix__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Camera.get_view_matrix", 
    "    Ogre::Matrix4 const & Camera.get_view_matrix()\n"
    "    Ogre::Matrix4 const & Camera.get_view_matrix(bool ownFrustumOnly)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Camera.set_use_rendering_distance

  call-seq:
    set_use_rendering_distance(bool use)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_use_rendering_distance(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);
  {
    try {
      (arg1)->setUseRenderingDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_use_rendering_distance

  call-seq:
    get_use_rendering_distance -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_use_rendering_distance(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);
  {
    try {
      result = (bool)((Ogre::Camera const *)arg1)->getUseRenderingDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.synchronise_base_settings_with

  call-seq:
    synchronise_base_settings_with(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_synchronise_base_settings_with(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);
  {
    try {
      (arg1)->synchroniseBaseSettingsWith((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_position_for_view_update

  call-seq:
    get_position_for_view_update -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_position_for_view_update(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Camera const *)arg1)->getPositionForViewUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_orientation_for_view_update

  call-seq:
    get_orientation_for_view_update -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_orientation_for_view_update(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);
  {
    try {
      result = (Ogre::Quaternion *) &((Ogre::Camera const *)arg1)->getOrientationForViewUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.set_use_min_pixel_size

  call-seq:
    set_use_min_pixel_size(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_set_use_min_pixel_size(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);
  {
    try {
      (arg1)->setUseMinPixelSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_use_min_pixel_size

  call-seq:
    get_use_min_pixel_size -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_use_min_pixel_size(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);
  {
    try {
      result = (bool)((Ogre::Camera const *)arg1)->getUseMinPixelSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Camera.get_pixel_display_ratio

  call-seq:
    get_pixel_display_ratio -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Camera_get_pixel_display_ratio(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Camera const *)arg1)->getPixelDisplayRatio();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Codec

  Proxy of C++ Ogre::Codec class


*/
swig_class SwigClassCodec;

SWIGINTERN void
free_Ogre_Codec(Ogre::Codec *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Codec.register_codec

  call-seq:
    register_codec(Codec pCodec)

A class method.

*/
SWIGINTERN VALUE
_wrap_Codec_register_codec(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);
  {
    try {
      Ogre::Codec::registerCodec(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Codec.is_codec_registered

  call-seq:
    is_codec_registered(String codecType) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_Codec_is_codec_registered(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;
  }
  {
    try {
      result = (bool)Ogre::Codec::isCodecRegistered((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}



/*
  Document-method: Ogre::Codec.un_register_codec

  call-seq:
    un_register_codec(Codec pCodec)

A class method.

*/
SWIGINTERN VALUE
_wrap_Codec_un_register_codec(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);
  {
    try {
      Ogre::Codec::unRegisterCodec(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Codec.get_codec_iterator

  call-seq:
    get_codec_iterator -> CodecIterator

A class method.

*/
SWIGINTERN VALUE
_wrap_Codec_get_codec_iterator(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;
  }
  {
    try {
      result = Ogre::Codec::getCodecIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Codec.get_extensions

  call-seq:
    get_extensions -> StringVector

A class method.

*/
SWIGINTERN VALUE
_wrap_Codec_get_extensions(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;
  }
  {
    try {
      result = Ogre::Codec::getExtensions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Codec.get_codec

  call-seq:
    get_codec(String extension) -> Codec
    get_codec(char magicNumberPtr, size_t maxbytes) -> Codec

A class method.

*/
SWIGINTERN VALUE
_wrap_Codec_get_codec__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;
  }
  {
    try {
      result = (Ogre::Codec *)Ogre::Codec::getCodec((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_get_codec__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);
  {
    try {
      result = (Ogre::Codec *)Ogre::Codec::getCodec(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_get_codec(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_get_codec__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_get_codec__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Codec.get_codec", 
    "    Ogre::Codec * Codec.get_codec(Ogre::String const &extension)\n"
    "    Ogre::Codec * Codec.get_codec(char *magicNumberPtr, size_t maxbytes)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Codec.code

  call-seq:
    code(MemoryDataStreamPtr input, CodecDataPtr pData) -> DataStreamPtr

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Codec const *)arg1)->code(*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Codec.code_to_file

  call-seq:
    code_to_file(MemoryDataStreamPtr input, String outFileName, CodecDataPtr pData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Codec_code_to_file(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);
  {
    try {
      ((Ogre::Codec const *)arg1)->codeToFile(*arg2,(Ogre::String const &)*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::Codec.decode

  call-seq:
    decode(DataStreamPtr input) -> DecodeResult

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::Codec const *)arg1)->decode(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Codec.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Codec_get_type(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);
  {
    try {
      result = ((Ogre::Codec const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Codec.get_data_type

  call-seq:
    get_data_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Codec_get_data_type(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);
  {
    try {
      result = ((Ogre::Codec const *)arg1)->getDataType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Codec.magic_number_match

  call-seq:
    magic_number_match(char magicNumberPtr, size_t maxbytes) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Codec_magic_number_match(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);
  {
    try {
      result = (bool)((Ogre::Codec const *)arg1)->magicNumberMatch((char const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}



/*
  Document-method: Ogre::Codec.magic_number_to_file_ext

  call-seq:
    magic_number_to_file_ext(char magicNumberPtr, size_t maxbytes) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Codec_magic_number_to_file_ext(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);
  {
    try {
      result = ((Ogre::Codec const *)arg1)->magicNumberToFileExt((char const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-class: Ogre::PixelBox < Ogre::Ogre::Box

  Proxy of C++ Ogre::PixelBox class


*/
swig_class SwigClassPixelBox;


/*
  Document-method: Ogre::PixelBox.new

  call-seq:
    PixelBox.new
    PixelBox.new(Box extents, PixelFormat pixelFormat, void pixelData=0)
    PixelBox.new(Box extents, PixelFormat pixelFormat)
    PixelBox.new(size_t width, size_t height, size_t depth, PixelFormat pixelFormat, 
    void pixelData=0)
    PixelBox.new(size_t width, size_t height, size_t depth, PixelFormat pixelFormat)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PixelBox *)new Ogre::PixelBox();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_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] )); 
  }
  {
    try {
      result = (Ogre::PixelBox *)new Ogre::PixelBox((Ogre::Box const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::PixelBox *)new Ogre::PixelBox((Ogre::Box const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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] )); 
  }
  {
    try {
      result = (Ogre::PixelBox *)new Ogre::PixelBox(arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::PixelBox *)new Ogre::PixelBox(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::PixelBox.data

  call-seq:
    data -> void

Get value of attribute.

*/

/*
  Document-method: Ogre::PixelBox.data=

  call-seq:
    data=(x) -> void

Set new value for attribute.

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



/*
  Document-method: Ogre::PixelBox.format

  call-seq:
    format -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::PixelBox.format=

  call-seq:
    format=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::PixelBox.rowPitch

  call-seq:
    rowPitch -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::PixelBox.rowPitch=

  call-seq:
    rowPitch=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::PixelBox.slicePitch

  call-seq:
    slicePitch -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::PixelBox.slicePitch=

  call-seq:
    slicePitch=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::PixelBox.set_consecutive

  call-seq:
    set_consecutive

An instance method.

*/
SWIGINTERN VALUE
_wrap_PixelBox_set_consecutive(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);
  {
    try {
      (arg1)->setConsecutive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelBox.get_row_skip

  call-seq:
    get_row_skip -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_PixelBox_get_row_skip(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);
  {
    try {
      result = ((Ogre::PixelBox const *)arg1)->getRowSkip();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelBox.get_slice_skip

  call-seq:
    get_slice_skip -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_PixelBox_get_slice_skip(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);
  {
    try {
      result = ((Ogre::PixelBox const *)arg1)->getSliceSkip();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelBox.is_consecutive

  call-seq:
    is_consecutive -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PixelBox_is_consecutive(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);
  {
    try {
      result = (bool)((Ogre::PixelBox const *)arg1)->isConsecutive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelBox.get_consecutive_size

  call-seq:
    get_consecutive_size -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_PixelBox_get_consecutive_size(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);
  {
    try {
      result = ((Ogre::PixelBox const *)arg1)->getConsecutiveSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelBox.get_sub_volume

  call-seq:
    get_sub_volume(Box def) -> PixelBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_PixelBox_get_sub_volume(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);
  {
    try {
      result = ((Ogre::PixelBox const *)arg1)->getSubVolume((Ogre::Box const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::PixelBox(static_cast< const Ogre::PixelBox& >(result))), SWIGTYPE_p_Ogre__PixelBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelBox.get_colour_at

  call-seq:
    get_colour_at(size_t x, size_t y, size_t z) -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_PixelBox_get_colour_at(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);
  {
    try {
      result = (arg1)->getColourAt(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelBox.set_colour_at

  call-seq:
    set_colour_at(ColourValue cv, size_t x, size_t y, size_t z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PixelBox_set_colour_at(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);
  {
    try {
      (arg1)->setColourAt((Ogre::ColourValue const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PixelUtil

  Proxy of C++ Ogre::PixelUtil class


*/
swig_class SwigClassPixelUtil;


/*
  Document-method: Ogre::PixelUtil.get_num_elem_bytes

  call-seq:
    get_num_elem_bytes(PixelFormat format) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_num_elem_bytes(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);
  {
    try {
      result = Ogre::PixelUtil::getNumElemBytes(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.get_num_elem_bits

  call-seq:
    get_num_elem_bits(PixelFormat format) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_num_elem_bits(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);
  {
    try {
      result = Ogre::PixelUtil::getNumElemBits(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.get_memory_size

  call-seq:
    get_memory_size(size_t width, size_t height, size_t depth, PixelFormat format) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_memory_size(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);
  {
    try {
      result = Ogre::PixelUtil::getMemorySize(arg1,arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.get_flags

  call-seq:
    get_flags(PixelFormat format) -> unsigned int

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_flags(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);
  {
    try {
      result = (unsigned int)Ogre::PixelUtil::getFlags(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.has_alpha

  call-seq:
    has_alpha(PixelFormat format) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_has_alpha(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);
  {
    try {
      result = (bool)Ogre::PixelUtil::hasAlpha(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.is_floating_point

  call-seq:
    is_floating_point(PixelFormat format) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_is_floating_point(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);
  {
    try {
      result = (bool)Ogre::PixelUtil::isFloatingPoint(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.is_compressed

  call-seq:
    is_compressed(PixelFormat format) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_is_compressed(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);
  {
    try {
      result = (bool)Ogre::PixelUtil::isCompressed(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.is_depth

  call-seq:
    is_depth(PixelFormat format) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_is_depth(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);
  {
    try {
      result = (bool)Ogre::PixelUtil::isDepth(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.is_native_endian

  call-seq:
    is_native_endian(PixelFormat format) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_is_native_endian(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);
  {
    try {
      result = (bool)Ogre::PixelUtil::isNativeEndian(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.is_luminance

  call-seq:
    is_luminance(PixelFormat format) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_is_luminance(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);
  {
    try {
      result = (bool)Ogre::PixelUtil::isLuminance(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.is_valid_extent

  call-seq:
    is_valid_extent(size_t width, size_t height, size_t depth, PixelFormat format) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_is_valid_extent(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);
  {
    try {
      result = (bool)Ogre::PixelUtil::isValidExtent(arg1,arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.get_bit_depths

  call-seq:
    get_bit_depths(PixelFormat format, int rgba)

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_bit_depths(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);
  {
    try {
      Ogre::PixelUtil::getBitDepths(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.get_bit_masks

  call-seq:
    get_bit_masks(PixelFormat format, uint32 rgba)

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_bit_masks(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);
  {
    try {
      Ogre::PixelUtil::getBitMasks(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.get_bit_shifts

  call-seq:
    get_bit_shifts(PixelFormat format, unsigned char rgba)

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_bit_shifts(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);
  {
    try {
      Ogre::PixelUtil::getBitShifts(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.get_format_name

  call-seq:
    get_format_name(PixelFormat srcformat) -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_format_name(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);
  {
    try {
      result = Ogre::PixelUtil::getFormatName(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.is_accessible

  call-seq:
    is_accessible(PixelFormat srcformat) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_is_accessible(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);
  {
    try {
      result = (bool)Ogre::PixelUtil::isAccessible(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.get_component_type

  call-seq:
    get_component_type(PixelFormat fmt) -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_component_type(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);
  {
    try {
      result = (Ogre::PixelComponentType)Ogre::PixelUtil::getComponentType(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.get_component_count

  call-seq:
    get_component_count(PixelFormat fmt) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_component_count(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);
  {
    try {
      result = Ogre::PixelUtil::getComponentCount(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.get_format_from_name

  call-seq:
    get_format_from_name(String name, bool accessibleOnly=false, bool caseSensitive=false) -> int
    get_format_from_name(String name, bool accessibleOnly=false) -> int
    get_format_from_name(String name) -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_format_from_name__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);
  {
    try {
      result = (Ogre::PixelFormat)Ogre::PixelUtil::getFormatFromName((std::string const &)*arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_get_format_from_name__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);
  {
    try {
      result = (Ogre::PixelFormat)Ogre::PixelUtil::getFormatFromName((std::string const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_get_format_from_name__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;
  }
  {
    try {
      result = (Ogre::PixelFormat)Ogre::PixelUtil::getFormatFromName((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_get_format_from_name(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_get_format_from_name__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_get_format_from_name__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_get_format_from_name__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PixelUtil.get_format_from_name", 
    "    Ogre::PixelFormat PixelUtil.get_format_from_name(Ogre::String const &name, bool accessibleOnly, bool caseSensitive)\n"
    "    Ogre::PixelFormat PixelUtil.get_format_from_name(Ogre::String const &name, bool accessibleOnly)\n"
    "    Ogre::PixelFormat PixelUtil.get_format_from_name(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.get_bnfexpression_of_pixel_formats

  call-seq:
    get_bnfexpression_of_pixel_formats(bool accessibleOnly=false) -> String
    get_bnfexpression_of_pixel_formats -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_bnfexpression_of_pixel_formats__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);
  {
    try {
      result = Ogre::PixelUtil::getBNFExpressionOfPixelFormats(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_get_bnfexpression_of_pixel_formats__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;
  }
  {
    try {
      result = Ogre::PixelUtil::getBNFExpressionOfPixelFormats();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PixelUtil_get_bnfexpression_of_pixel_formats(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_get_bnfexpression_of_pixel_formats__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_get_bnfexpression_of_pixel_formats__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PixelUtil.get_bnfexpression_of_pixel_formats", 
    "    Ogre::String PixelUtil.get_bnfexpression_of_pixel_formats(bool accessibleOnly)\n"
    "    Ogre::String PixelUtil.get_bnfexpression_of_pixel_formats()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.get_format_for_bit_depths

  call-seq:
    get_format_for_bit_depths(PixelFormat fmt, ushort integerBits, ushort floatBits) -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_get_format_for_bit_depths(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);
  {
    try {
      result = (Ogre::PixelFormat)Ogre::PixelUtil::getFormatForBitDepths(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.pack_colour

  call-seq:
    pack_colour(ColourValue colour, PixelFormat pf, void dest)
    pack_colour(uint8 r, uint8 g, uint8 b, uint8 a, PixelFormat pf, 
    void dest)
    pack_colour(float r, float g, float b, float a, PixelFormat pf, 
    void dest)

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_pack_colour__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] )); 
  }
  {
    try {
      Ogre::PixelUtil::packColour((Ogre::ColourValue const &)*arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_pack_colour__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] )); 
  }
  {
    try {
      Ogre::PixelUtil::packColour(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_pack_colour__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] )); 
  }
  {
    try {
      Ogre::PixelUtil::packColour(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PixelUtil_pack_colour(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_pack_colour__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_pack_colour__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_pack_colour__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "PixelUtil.pack_colour", 
    "    void PixelUtil.pack_colour(Ogre::ColourValue const &colour, Ogre::PixelFormat const pf, void *dest)\n"
    "    void PixelUtil.pack_colour(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.pack_colour(float const r, float const g, float const b, float const a, Ogre::PixelFormat const pf, void *dest)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.unpack_colour

  call-seq:
    unpack_colour(ColourValue colour, PixelFormat pf, void src)
    unpack_colour(uint8 r, uint8 g, uint8 b, uint8 a, PixelFormat pf, 
    void src)
    unpack_colour(float r, float g, float b, float a, PixelFormat pf, 
    void src)

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_unpack_colour__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] )); 
  }
  {
    try {
      Ogre::PixelUtil::unpackColour(arg1,arg2,(void const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_unpack_colour__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] )); 
  }
  {
    try {
      Ogre::PixelUtil::unpackColour(arg1,arg2,arg3,arg4,arg5,(void const *)arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_unpack_colour__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] )); 
  }
  {
    try {
      Ogre::PixelUtil::unpackColour(arg1,arg2,arg3,arg4,arg5,(void const *)arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PixelUtil_unpack_colour(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_unpack_colour__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_unpack_colour__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_unpack_colour__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "PixelUtil.unpack_colour", 
    "    void PixelUtil.unpack_colour(Ogre::ColourValue *colour, Ogre::PixelFormat pf, void const *src)\n"
    "    void PixelUtil.unpack_colour(Ogre::uint8 *r, Ogre::uint8 *g, Ogre::uint8 *b, Ogre::uint8 *a, Ogre::PixelFormat pf, void const *src)\n"
    "    void PixelUtil.unpack_colour(float *r, float *g, float *b, float *a, Ogre::PixelFormat pf, void const *src)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PixelUtil.bulk_pixel_conversion

  call-seq:
    bulk_pixel_conversion(void src, PixelFormat srcFormat, void dest, PixelFormat dstFormat, 
    unsigned int count)
    bulk_pixel_conversion(PixelBox src, PixelBox dst)

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelUtil_bulk_pixel_conversion__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);
  {
    try {
      Ogre::PixelUtil::bulkPixelConversion(arg1,arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_bulk_pixel_conversion__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);
  {
    try {
      Ogre::PixelUtil::bulkPixelConversion((Ogre::PixelBox const &)*arg1,(Ogre::PixelBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PixelUtil_bulk_pixel_conversion(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_bulk_pixel_conversion__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_bulk_pixel_conversion__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "PixelUtil.bulk_pixel_conversion", 
    "    void PixelUtil.bulk_pixel_conversion(void *src, Ogre::PixelFormat srcFormat, void *dest, Ogre::PixelFormat dstFormat, unsigned int count)\n"
    "    void PixelUtil.bulk_pixel_conversion(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;
  }
  


/*
  Document-method: Ogre::PixelUtil.new

  call-seq:
    PixelUtil.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PixelUtil *)new Ogre::PixelUtil();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PixelUtil(Ogre::PixelUtil *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::Image

  Proxy of C++ Ogre::Image class


*/
swig_class SwigClassImage;


/*
  Document-method: Ogre::Image.new

  call-seq:
    Image.new
    Image.new(Image img)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Image *)new Ogre::Image();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Image *)new Ogre::Image((Ogre::Image const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::Image.flip_around_y

  call-seq:
    flip_around_y -> Image

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_flip_around_y(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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->flipAroundY();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.flip_around_x

  call-seq:
    flip_around_x -> Image

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_flip_around_x(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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->flipAroundX();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.load_dynamic_image

  call-seq:
    load_dynamic_image(uchar data, size_t width, size_t height, size_t depth, 
    PixelFormat format, bool autoDelete=false, 
    size_t numFaces=1, size_t numMipMaps=0) -> Image
    load_dynamic_image(uchar data, size_t width, size_t height, size_t depth, 
    PixelFormat format, bool autoDelete=false, 
    size_t numFaces=1) -> Image
    load_dynamic_image(uchar data, size_t width, size_t height, size_t depth, 
    PixelFormat format, bool autoDelete=false) -> Image
    load_dynamic_image(uchar data, size_t width, size_t height, size_t depth, 
    PixelFormat format) -> Image
    load_dynamic_image(uchar data, size_t width, size_t height, PixelFormat format) -> Image

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_load_dynamic_image__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadDynamicImage(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_load_dynamic_image__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadDynamicImage(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_load_dynamic_image__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadDynamicImage(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_load_dynamic_image__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadDynamicImage(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_load_dynamic_image__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadDynamicImage(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_load_dynamic_image(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_load_dynamic_image__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_load_dynamic_image__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_load_dynamic_image__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_load_dynamic_image__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_load_dynamic_image__SWIG_0(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 10, "Image.load_dynamic_image", 
    "    Ogre::Image & Image.load_dynamic_image(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.load_dynamic_image(Ogre::uchar *data, size_t width, size_t height, size_t depth, Ogre::PixelFormat format, bool autoDelete, size_t numFaces)\n"
    "    Ogre::Image & Image.load_dynamic_image(Ogre::uchar *data, size_t width, size_t height, size_t depth, Ogre::PixelFormat format, bool autoDelete)\n"
    "    Ogre::Image & Image.load_dynamic_image(Ogre::uchar *data, size_t width, size_t height, size_t depth, Ogre::PixelFormat format)\n"
    "    Ogre::Image & Image.load_dynamic_image(Ogre::uchar *data, size_t width, size_t height, Ogre::PixelFormat format)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Image.load_raw_data

  call-seq:
    load_raw_data(DataStreamPtr stream, size_t width, size_t height, 
    size_t depth, PixelFormat format, size_t numFaces=1, 
    size_t numMipMaps=0) -> Image
    load_raw_data(DataStreamPtr stream, size_t width, size_t height, 
    size_t depth, PixelFormat format, size_t numFaces=1) -> Image
    load_raw_data(DataStreamPtr stream, size_t width, size_t height, 
    size_t depth, PixelFormat format) -> Image
    load_raw_data(DataStreamPtr stream, size_t width, size_t height, 
    PixelFormat format) -> Image

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_load_raw_data__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadRawData(*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_load_raw_data__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadRawData(*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_load_raw_data__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadRawData(*arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_load_raw_data__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadRawData(*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_load_raw_data(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_load_raw_data__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_load_raw_data__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_load_raw_data__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_load_raw_data__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "Image.load_raw_data", 
    "    Ogre::Image & Image.load_raw_data(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.load_raw_data(Ogre::DataStreamPtr &stream, size_t width, size_t height, size_t depth, Ogre::PixelFormat format, size_t numFaces)\n"
    "    Ogre::Image & Image.load_raw_data(Ogre::DataStreamPtr &stream, size_t width, size_t height, size_t depth, Ogre::PixelFormat format)\n"
    "    Ogre::Image & Image.load_raw_data(Ogre::DataStreamPtr &stream, size_t width, size_t height, Ogre::PixelFormat format)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Image.load

  call-seq:
    load(String filename, String groupName) -> Image
    load(DataStreamPtr stream, String type=BLANK) -> Image
    load(DataStreamPtr stream) -> Image

An instance method.

*/
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;
  }
  {
    try {
      result = (Ogre::Image *) &(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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;
  }
  {
    try {
      result = (Ogre::Image *) &(arg1)->load(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->load(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::Image.load_two_images_as_rgba

  call-seq:
    load_two_images_as_rgba(String rgbFilename, String alphaFilename, String groupName, 
    PixelFormat format=PF_BYTE_RGBA) -> Image
    load_two_images_as_rgba(String rgbFilename, String alphaFilename, String groupName) -> Image
    load_two_images_as_rgba(DataStreamPtr rgbStream, DataStreamPtr alphaStream, 
    PixelFormat ?=PF_BYTE_RGBA, String rgbType=BLANK, 
    String alphaType=BLANK) -> Image
    load_two_images_as_rgba(DataStreamPtr rgbStream, DataStreamPtr alphaStream, 
    PixelFormat ?=PF_BYTE_RGBA, String rgbType=BLANK) -> Image
    load_two_images_as_rgba(DataStreamPtr rgbStream, DataStreamPtr alphaStream, 
    PixelFormat ?=PF_BYTE_RGBA) -> Image
    load_two_images_as_rgba(DataStreamPtr rgbStream, DataStreamPtr alphaStream) -> Image

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_load_two_images_as_rgba__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadTwoImagesAsRGBA((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_load_two_images_as_rgba__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;
  }
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadTwoImagesAsRGBA((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_load_two_images_as_rgba__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;
  }
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadTwoImagesAsRGBA(*arg2,*arg3,arg4,(Ogre::String const &)*arg5,(Ogre::String const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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_load_two_images_as_rgba__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;
  }
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadTwoImagesAsRGBA(*arg2,*arg3,arg4,(Ogre::String const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_load_two_images_as_rgba__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadTwoImagesAsRGBA(*arg2,*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_load_two_images_as_rgba__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->loadTwoImagesAsRGBA(*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_load_two_images_as_rgba(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_load_two_images_as_rgba__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_load_two_images_as_rgba__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_load_two_images_as_rgba__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_load_two_images_as_rgba__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_load_two_images_as_rgba__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_load_two_images_as_rgba__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Image.load_two_images_as_rgba", 
    "    Ogre::Image & Image.load_two_images_as_rgba(Ogre::String const &rgbFilename, Ogre::String const &alphaFilename, Ogre::String const &groupName, Ogre::PixelFormat format)\n"
    "    Ogre::Image & Image.load_two_images_as_rgba(Ogre::String const &rgbFilename, Ogre::String const &alphaFilename, Ogre::String const &groupName)\n"
    "    Ogre::Image & Image.load_two_images_as_rgba(Ogre::DataStreamPtr &rgbStream, Ogre::DataStreamPtr &alphaStream, Ogre::PixelFormat, Ogre::String const &rgbType, Ogre::String const &alphaType)\n"
    "    Ogre::Image & Image.load_two_images_as_rgba(Ogre::DataStreamPtr &rgbStream, Ogre::DataStreamPtr &alphaStream, Ogre::PixelFormat, Ogre::String const &rgbType)\n"
    "    Ogre::Image & Image.load_two_images_as_rgba(Ogre::DataStreamPtr &rgbStream, Ogre::DataStreamPtr &alphaStream, Ogre::PixelFormat)\n"
    "    Ogre::Image & Image.load_two_images_as_rgba(Ogre::DataStreamPtr &rgbStream, Ogre::DataStreamPtr &alphaStream)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Image.combine_two_images_as_rgba

  call-seq:
    combine_two_images_as_rgba(Image rgb, Image alpha, PixelFormat format=PF_BYTE_RGBA) -> Image
    combine_two_images_as_rgba(Image rgb, Image alpha) -> Image

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_combine_two_images_as_rgba__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->combineTwoImagesAsRGBA((Ogre::Image const &)*arg2,(Ogre::Image const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_combine_two_images_as_rgba__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);
  {
    try {
      result = (Ogre::Image *) &(arg1)->combineTwoImagesAsRGBA((Ogre::Image const &)*arg2,(Ogre::Image const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_combine_two_images_as_rgba(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_combine_two_images_as_rgba__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_combine_two_images_as_rgba__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Image.combine_two_images_as_rgba", 
    "    Ogre::Image & Image.combine_two_images_as_rgba(Ogre::Image const &rgb, Ogre::Image const &alpha, Ogre::PixelFormat format)\n"
    "    Ogre::Image & Image.combine_two_images_as_rgba(Ogre::Image const &rgb, Ogre::Image const &alpha)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Image.save

  call-seq:
    save(String filename)

An instance method.

*/
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;
  }
  {
    try {
      (arg1)->save((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Image.encode

  call-seq:
    encode(String formatextension) -> DataStreamPtr

An instance method.

*/
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;
  }
  {
    try {
      result = (arg1)->encode((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Image.get_data

  call-seq:
    get_data -> uchar
    get_data -> uchar

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_data__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);
  {
    try {
      result = (Ogre::uchar *)(arg1)->getData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_get_data__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);
  {
    try {
      result = (Ogre::uchar *)((Ogre::Image const *)arg1)->getData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_get_data(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_get_data__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_get_data__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Image.get_data", 
    "    Ogre::uchar const * Image.get_data()\n"
    "    Ogre::uchar const * Image.get_data()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_size

  call-seq:
    get_size -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_size(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);
  {
    try {
      result = ((Ogre::Image const *)arg1)->getSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_num_mipmaps

  call-seq:
    get_num_mipmaps -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_num_mipmaps(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);
  {
    try {
      result = ((Ogre::Image const *)arg1)->getNumMipmaps();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.has_flag

  call-seq:
    has_flag(ImageFlags imgFlag) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_has_flag(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);
  {
    try {
      result = (bool)((Ogre::Image const *)arg1)->hasFlag(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_width

  call-seq:
    get_width -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_width(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);
  {
    try {
      result = ((Ogre::Image const *)arg1)->getWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_height

  call-seq:
    get_height -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_height(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);
  {
    try {
      result = ((Ogre::Image const *)arg1)->getHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_depth

  call-seq:
    get_depth -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_depth(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);
  {
    try {
      result = ((Ogre::Image const *)arg1)->getDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_num_faces

  call-seq:
    get_num_faces -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_num_faces(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);
  {
    try {
      result = ((Ogre::Image const *)arg1)->getNumFaces();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_row_span

  call-seq:
    get_row_span -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_row_span(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);
  {
    try {
      result = ((Ogre::Image const *)arg1)->getRowSpan();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_format

  call-seq:
    get_format -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_format(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);
  {
    try {
      result = (Ogre::PixelFormat)((Ogre::Image const *)arg1)->getFormat();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_bpp

  call-seq:
    get_bpp -> uchar

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_bpp(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);
  {
    try {
      result = (Ogre::uchar)((Ogre::Image const *)arg1)->getBPP();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_has_alpha

  call-seq:
    get_has_alpha -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_has_alpha(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);
  {
    try {
      result = (bool)((Ogre::Image const *)arg1)->getHasAlpha();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.apply_gamma

  call-seq:
    apply_gamma(uchar buffer, Real gamma, size_t size, uchar bpp)

A class method.

*/
SWIGINTERN VALUE
_wrap_Image_apply_gamma(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);
  {
    try {
      Ogre::Image::applyGamma(arg1,arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_colour_at

  call-seq:
    get_colour_at(size_t x, size_t y, size_t z) -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_colour_at(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);
  {
    try {
      result = ((Ogre::Image const *)arg1)->getColourAt(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.set_colour_at

  call-seq:
    set_colour_at(ColourValue cv, size_t x, size_t y, size_t z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_set_colour_at(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);
  {
    try {
      (arg1)->setColourAt((Ogre::ColourValue const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_pixel_box

  call-seq:
    get_pixel_box(size_t face=0, size_t mipmap=0) -> PixelBox
    get_pixel_box(size_t face=0) -> PixelBox
    get_pixel_box -> PixelBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_get_pixel_box__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);
  {
    try {
      result = ((Ogre::Image const *)arg1)->getPixelBox(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::PixelBox(static_cast< const Ogre::PixelBox& >(result))), SWIGTYPE_p_Ogre__PixelBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_get_pixel_box__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);
  {
    try {
      result = ((Ogre::Image const *)arg1)->getPixelBox(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::PixelBox(static_cast< const Ogre::PixelBox& >(result))), SWIGTYPE_p_Ogre__PixelBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_get_pixel_box__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);
  {
    try {
      result = ((Ogre::Image const *)arg1)->getPixelBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::PixelBox(static_cast< const Ogre::PixelBox& >(result))), SWIGTYPE_p_Ogre__PixelBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_get_pixel_box(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_get_pixel_box__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_get_pixel_box__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_get_pixel_box__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Image.get_pixel_box", 
    "    Ogre::PixelBox Image.get_pixel_box(size_t face, size_t mipmap)\n"
    "    Ogre::PixelBox Image.get_pixel_box(size_t face)\n"
    "    Ogre::PixelBox Image.get_pixel_box()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Image.free_memory

  call-seq:
    free_memory

An instance method.

*/
SWIGINTERN VALUE
_wrap_Image_free_memory(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);
  {
    try {
      (arg1)->freeMemory();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Filter.FILTER_NEAREST

  call-seq:
    FILTER_NEAREST -> int

A class method.

*/

/*
  Document-method: Ogre::Filter.FILTER_LINEAR

  call-seq:
    FILTER_LINEAR -> int

A class method.

*/

/*
  Document-method: Ogre::Filter.FILTER_BILINEAR

  call-seq:
    FILTER_BILINEAR -> int

A class method.

*/

/*
  Document-method: Ogre::Filter.FILTER_BOX

  call-seq:
    FILTER_BOX -> int

A class method.

*/

/*
  Document-method: Ogre::Filter.FILTER_TRIANGLE

  call-seq:
    FILTER_TRIANGLE -> int

A class method.

*/

/*
  Document-method: Ogre::Filter.FILTER_BICUBIC

  call-seq:
    FILTER_BICUBIC -> int

A class method.

*/

/*
  Document-method: Ogre::Image.scale

  call-seq:
    scale(PixelBox src, PixelBox dst, Filter filter=FILTER_BILINEAR)
    scale(PixelBox src, PixelBox dst)

A class method.

*/
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);
  {
    try {
      Ogre::Image::scale((Ogre::PixelBox const &)*arg1,(Ogre::PixelBox const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      Ogre::Image::scale((Ogre::PixelBox const &)*arg1,(Ogre::PixelBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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);
  {
    try {
      (arg1)->resize(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->resize(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Image.calculate_size

  call-seq:
    calculate_size(size_t mipmaps, size_t faces, size_t width, size_t height, 
    size_t depth, PixelFormat format) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_Image_calculate_size(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);
  {
    try {
      result = Ogre::Image::calculateSize(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Image.get_file_ext_from_magic

  call-seq:
    get_file_ext_from_magic(DataStreamPtr stream) -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_Image_get_file_ext_from_magic(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));
    }
  }
  {
    try {
      result = Ogre::Image::getFileExtFromMagic(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Texture < Ogre::Ogre::Resource

  Proxy of C++ Ogre::Texture class


*/
swig_class SwigClassTexture;


/*
  Document-method: Ogre::Texture.set_texture_type

  call-seq:
    set_texture_type(TextureType ttype)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_texture_type(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);
  {
    try {
      (arg1)->setTextureType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_texture_type

  call-seq:
    get_texture_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_texture_type(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);
  {
    try {
      result = (Ogre::TextureType)((Ogre::Texture const *)arg1)->getTextureType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_num_mipmaps

  call-seq:
    get_num_mipmaps -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_num_mipmaps(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);
  {
    try {
      result = ((Ogre::Texture const *)arg1)->getNumMipmaps();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_num_mipmaps

  call-seq:
    set_num_mipmaps(size_t num)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_num_mipmaps(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);
  {
    try {
      (arg1)->setNumMipmaps(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_mipmaps_hardware_generated

  call-seq:
    get_mipmaps_hardware_generated -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_mipmaps_hardware_generated(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);
  {
    try {
      result = (bool)((Ogre::Texture const *)arg1)->getMipmapsHardwareGenerated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_gamma

  call-seq:
    get_gamma -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_gamma(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);
  {
    try {
      result = (float)((Ogre::Texture const *)arg1)->getGamma();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_gamma

  call-seq:
    set_gamma(float g)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_gamma(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);
  {
    try {
      (arg1)->setGamma(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_hardware_gamma_enabled

  call-seq:
    set_hardware_gamma_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_hardware_gamma_enabled(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);
  {
    try {
      (arg1)->setHardwareGammaEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.is_hardware_gamma_enabled

  call-seq:
    is_hardware_gamma_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_is_hardware_gamma_enabled(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);
  {
    try {
      result = (bool)((Ogre::Texture const *)arg1)->isHardwareGammaEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_fsaa

  call-seq:
    set_fsaa(uint fsaa, String fsaaHint)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_fsaa(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;
  }
  {
    try {
      (arg1)->setFSAA(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_fsaa

  call-seq:
    get_fsaa -> uint

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_fsaa(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);
  {
    try {
      result = (Ogre::uint)((Ogre::Texture const *)arg1)->getFSAA();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_fsaahint

  call-seq:
    get_fsaahint -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_fsaahint(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Texture const *)arg1)->getFSAAHint();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_height

  call-seq:
    get_height -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_height(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);
  {
    try {
      result = ((Ogre::Texture const *)arg1)->getHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_width

  call-seq:
    get_width -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_width(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);
  {
    try {
      result = ((Ogre::Texture const *)arg1)->getWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_depth

  call-seq:
    get_depth -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_depth(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);
  {
    try {
      result = ((Ogre::Texture const *)arg1)->getDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_src_height

  call-seq:
    get_src_height -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_src_height(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);
  {
    try {
      result = ((Ogre::Texture const *)arg1)->getSrcHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_src_width

  call-seq:
    get_src_width -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_src_width(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);
  {
    try {
      result = ((Ogre::Texture const *)arg1)->getSrcWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_src_depth

  call-seq:
    get_src_depth -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_src_depth(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);
  {
    try {
      result = ((Ogre::Texture const *)arg1)->getSrcDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_height

  call-seq:
    set_height(size_t h)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_height(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);
  {
    try {
      (arg1)->setHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_width

  call-seq:
    set_width(size_t w)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_width(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);
  {
    try {
      (arg1)->setWidth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_depth

  call-seq:
    set_depth(size_t d)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_depth(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);
  {
    try {
      (arg1)->setDepth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_usage

  call-seq:
    get_usage -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_usage(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);
  {
    try {
      result = (int)((Ogre::Texture const *)arg1)->getUsage();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_usage

  call-seq:
    set_usage(int u)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_usage(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);
  {
    try {
      (arg1)->setUsage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.create_internal_resources

  call-seq:
    create_internal_resources

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_create_internal_resources(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);
  {
    try {
      (arg1)->createInternalResources();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.free_internal_resources

  call-seq:
    free_internal_resources

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_free_internal_resources(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);
  {
    try {
      (arg1)->freeInternalResources();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.copy_to_texture

  call-seq:
    copy_to_texture(TexturePtr target)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_copy_to_texture(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);
  {
    try {
      (arg1)->copyToTexture(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.load_image

  call-seq:
    load_image(Image img)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_load_image(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);
  {
    try {
      (arg1)->loadImage((Ogre::Image const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.load_raw_data

  call-seq:
    load_raw_data(DataStreamPtr stream, ushort uWidth, ushort uHeight, 
    PixelFormat eFormat)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_load_raw_data(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);
  {
    try {
      (arg1)->loadRawData(*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture._load_images

  call-seq:
    _load_images(ConstImagePtrList images)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture__load_images(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);
  {
    try {
      (arg1)->_loadImages((Ogre::ConstImagePtrList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_format

  call-seq:
    get_format -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_format(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);
  {
    try {
      result = (Ogre::PixelFormat)((Ogre::Texture const *)arg1)->getFormat();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_desired_format

  call-seq:
    get_desired_format -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_desired_format(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);
  {
    try {
      result = (Ogre::PixelFormat)((Ogre::Texture const *)arg1)->getDesiredFormat();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_src_format

  call-seq:
    get_src_format -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_src_format(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);
  {
    try {
      result = (Ogre::PixelFormat)((Ogre::Texture const *)arg1)->getSrcFormat();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_format

  call-seq:
    set_format(PixelFormat pf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_format(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);
  {
    try {
      (arg1)->setFormat(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.has_alpha

  call-seq:
    has_alpha -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_has_alpha(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);
  {
    try {
      result = (bool)((Ogre::Texture const *)arg1)->hasAlpha();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_desired_integer_bit_depth

  call-seq:
    set_desired_integer_bit_depth(ushort bits)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_desired_integer_bit_depth(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);
  {
    try {
      (arg1)->setDesiredIntegerBitDepth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_desired_integer_bit_depth

  call-seq:
    get_desired_integer_bit_depth -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_desired_integer_bit_depth(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::Texture const *)arg1)->getDesiredIntegerBitDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_desired_float_bit_depth

  call-seq:
    set_desired_float_bit_depth(ushort bits)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_desired_float_bit_depth(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);
  {
    try {
      (arg1)->setDesiredFloatBitDepth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_desired_float_bit_depth

  call-seq:
    get_desired_float_bit_depth -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_desired_float_bit_depth(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::Texture const *)arg1)->getDesiredFloatBitDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_desired_bit_depths

  call-seq:
    set_desired_bit_depths(ushort integerBits, ushort floatBits)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_desired_bit_depths(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);
  {
    try {
      (arg1)->setDesiredBitDepths(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.set_treat_luminance_as_alpha

  call-seq:
    set_treat_luminance_as_alpha(bool asAlpha)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_set_treat_luminance_as_alpha(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);
  {
    try {
      (arg1)->setTreatLuminanceAsAlpha(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_treat_luminance_as_alpha

  call-seq:
    get_treat_luminance_as_alpha -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_treat_luminance_as_alpha(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);
  {
    try {
      result = (bool)((Ogre::Texture const *)arg1)->getTreatLuminanceAsAlpha();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_num_faces

  call-seq:
    get_num_faces -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_num_faces(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);
  {
    try {
      result = ((Ogre::Texture const *)arg1)->getNumFaces();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_buffer

  call-seq:
    get_buffer(size_t face=0, size_t mipmap=0) -> HardwarePixelBufferSharedPtr
    get_buffer(size_t face=0) -> HardwarePixelBufferSharedPtr
    get_buffer -> HardwarePixelBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_buffer__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);
  {
    try {
      result = (arg1)->getBuffer(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::HardwarePixelBufferSharedPtr(static_cast< const Ogre::HardwarePixelBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwarePixelBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_get_buffer__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);
  {
    try {
      result = (arg1)->getBuffer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::HardwarePixelBufferSharedPtr(static_cast< const Ogre::HardwarePixelBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwarePixelBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_get_buffer__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);
  {
    try {
      result = (arg1)->getBuffer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::HardwarePixelBufferSharedPtr(static_cast< const Ogre::HardwarePixelBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwarePixelBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Texture_get_buffer(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_get_buffer__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_get_buffer__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_get_buffer__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Texture.get_buffer", 
    "    Ogre::HardwarePixelBufferSharedPtr Texture.get_buffer(size_t face, size_t mipmap)\n"
    "    Ogre::HardwarePixelBufferSharedPtr Texture.get_buffer(size_t face)\n"
    "    Ogre::HardwarePixelBufferSharedPtr Texture.get_buffer()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Texture.convert_to_image

  call-seq:
    convert_to_image(Image destImage, bool includeMipMaps=false)
    convert_to_image(Image destImage)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_convert_to_image__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);
  {
    try {
      (arg1)->convertToImage(*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_convert_to_image__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);
  {
    try {
      (arg1)->convertToImage(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Texture_convert_to_image(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_convert_to_image__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_convert_to_image__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Texture.convert_to_image", 
    "    void Texture.convert_to_image(Ogre::Image &destImage, bool includeMipMaps)\n"
    "    void Texture.convert_to_image(Ogre::Image &destImage)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Texture.get_custom_attribute

  call-seq:
    get_custom_attribute(String name, void pData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Texture_get_custom_attribute(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] )); 
  }
  {
    try {
      (arg1)->getCustomAttribute((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_Ogre_Texture(Ogre::Texture *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::TexturePtr

  Proxy of C++ Ogre::TexturePtr class


*/
swig_class SwigClassTexturePtr;


/*
  Document-method: Ogre::TexturePtr.new

  call-seq:
    TexturePtr.new
    TexturePtr.new(Texture rep)
    TexturePtr.new(TexturePtr r)
    TexturePtr.new(ResourcePtr r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TexturePtr *)new Ogre::TexturePtr();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::TexturePtr *)new Ogre::TexturePtr(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::TexturePtr *)new Ogre::TexturePtr((Ogre::TexturePtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::TexturePtr *)new Ogre::TexturePtr((Ogre::ResourcePtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::TextureUnitState

  Proxy of C++ Ogre::TextureUnitState class


*/
swig_class SwigClassTextureUnitState;


/*
  Document-method: Ogre::TextureEffectType.ET_ENVIRONMENT_MAP

  call-seq:
    ET_ENVIRONMENT_MAP -> int

A class method.

*/

/*
  Document-method: Ogre::TextureEffectType.ET_PROJECTIVE_TEXTURE

  call-seq:
    ET_PROJECTIVE_TEXTURE -> int

A class method.

*/

/*
  Document-method: Ogre::TextureEffectType.ET_UVSCROLL

  call-seq:
    ET_UVSCROLL -> int

A class method.

*/

/*
  Document-method: Ogre::TextureEffectType.ET_USCROLL

  call-seq:
    ET_USCROLL -> int

A class method.

*/

/*
  Document-method: Ogre::TextureEffectType.ET_VSCROLL

  call-seq:
    ET_VSCROLL -> int

A class method.

*/

/*
  Document-method: Ogre::TextureEffectType.ET_ROTATE

  call-seq:
    ET_ROTATE -> int

A class method.

*/

/*
  Document-method: Ogre::TextureEffectType.ET_TRANSFORM

  call-seq:
    ET_TRANSFORM -> int

A class method.

*/

/*
  Document-method: Ogre::EnvMapType.ENV_PLANAR

  call-seq:
    ENV_PLANAR -> int

A class method.

*/

/*
  Document-method: Ogre::EnvMapType.ENV_CURVED

  call-seq:
    ENV_CURVED -> int

A class method.

*/

/*
  Document-method: Ogre::EnvMapType.ENV_REFLECTION

  call-seq:
    ENV_REFLECTION -> int

A class method.

*/

/*
  Document-method: Ogre::EnvMapType.ENV_NORMAL

  call-seq:
    ENV_NORMAL -> int

A class method.

*/

/*
  Document-method: Ogre::TextureTransformType.TT_TRANSLATE_U

  call-seq:
    TT_TRANSLATE_U -> int

A class method.

*/

/*
  Document-method: Ogre::TextureTransformType.TT_TRANSLATE_V

  call-seq:
    TT_TRANSLATE_V -> int

A class method.

*/

/*
  Document-method: Ogre::TextureTransformType.TT_SCALE_U

  call-seq:
    TT_SCALE_U -> int

A class method.

*/

/*
  Document-method: Ogre::TextureTransformType.TT_SCALE_V

  call-seq:
    TT_SCALE_V -> int

A class method.

*/

/*
  Document-method: Ogre::TextureTransformType.TT_ROTATE

  call-seq:
    TT_ROTATE -> int

A class method.

*/

/*
  Document-method: Ogre::TextureAddressingMode.TAM_WRAP

  call-seq:
    TAM_WRAP -> int

A class method.

*/

/*
  Document-method: Ogre::TextureAddressingMode.TAM_MIRROR

  call-seq:
    TAM_MIRROR -> int

A class method.

*/

/*
  Document-method: Ogre::TextureAddressingMode.TAM_CLAMP

  call-seq:
    TAM_CLAMP -> int

A class method.

*/

/*
  Document-method: Ogre::TextureAddressingMode.TAM_BORDER

  call-seq:
    TAM_BORDER -> int

A class method.

*/

/*
  Document-method: Ogre::TextureCubeFace.CUBE_FRONT

  call-seq:
    CUBE_FRONT -> int

A class method.

*/

/*
  Document-method: Ogre::TextureCubeFace.CUBE_BACK

  call-seq:
    CUBE_BACK -> int

A class method.

*/

/*
  Document-method: Ogre::TextureCubeFace.CUBE_LEFT

  call-seq:
    CUBE_LEFT -> int

A class method.

*/

/*
  Document-method: Ogre::TextureCubeFace.CUBE_RIGHT

  call-seq:
    CUBE_RIGHT -> int

A class method.

*/

/*
  Document-method: Ogre::TextureCubeFace.CUBE_UP

  call-seq:
    CUBE_UP -> int

A class method.

*/

/*
  Document-method: Ogre::TextureCubeFace.CUBE_DOWN

  call-seq:
    CUBE_DOWN -> int

A class method.

*/

/*
  Document-method: Ogre::TextureUnitState.new

  call-seq:
    TextureUnitState.new(Pass parent)
    TextureUnitState.new(Pass parent, TextureUnitState oth)
    TextureUnitState.new(Pass parent, String texName, unsigned int texCoordSet=0)
    TextureUnitState.new(Pass parent, String texName)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::TextureUnitState *)new Ogre::TextureUnitState(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::TextureUnitState *)new Ogre::TextureUnitState(arg1,(Ogre::TextureUnitState const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      result = (Ogre::TextureUnitState *)new Ogre::TextureUnitState(arg1,(Ogre::String const &)*arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::TextureUnitState *)new Ogre::TextureUnitState(arg1,(Ogre::String const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_name

  call-seq:
    get_texture_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::TextureUnitState const *)arg1)->getTextureName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_name

  call-seq:
    set_texture_name(String name, TextureType ttype=TEX_TYPE_2D)
    set_texture_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_name__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);
  {
    try {
      (arg1)->setTextureName((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_name__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;
  }
  {
    try {
      (arg1)->setTextureName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_set_texture_name(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_set_texture_name__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_set_texture_name__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState.set_texture_name", 
    "    void TextureUnitState.set_texture_name(Ogre::String const &name, Ogre::TextureType ttype)\n"
    "    void TextureUnitState.set_texture_name(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture

  call-seq:
    set_texture(TexturePtr texPtr)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture(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);
  {
    try {
      (arg1)->setTexture((Ogre::TexturePtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_cubic_texture_name

  call-seq:
    set_cubic_texture_name(String name, bool forUVW=false)
    set_cubic_texture_name(String name)
    set_cubic_texture_name(String names, bool forUVW=false)
    set_cubic_texture_name(String names)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_cubic_texture_name__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);
  {
    try {
      (arg1)->setCubicTextureName((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_cubic_texture_name__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;
  }
  {
    try {
      (arg1)->setCubicTextureName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_cubic_texture_name__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);
  {
    try {
      (arg1)->setCubicTextureName((Ogre::String const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_cubic_texture_name__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);
  {
    try {
      (arg1)->setCubicTextureName((Ogre::String const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_set_cubic_texture_name(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_set_cubic_texture_name__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_set_cubic_texture_name__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_set_cubic_texture_name__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_set_cubic_texture_name__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState.set_cubic_texture_name", 
    "    void TextureUnitState.set_cubic_texture_name(Ogre::String const &name, bool forUVW)\n"
    "    void TextureUnitState.set_cubic_texture_name(Ogre::String const &name)\n"
    "    void TextureUnitState.set_cubic_texture_name(Ogre::String const *const names, bool forUVW)\n"
    "    void TextureUnitState.set_cubic_texture_name(Ogre::String const *const names)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_cubic_texture

  call-seq:
    set_cubic_texture(TexturePtr texPtrs, bool forUVW=false)
    set_cubic_texture(TexturePtr texPtrs)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_cubic_texture__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);
  {
    try {
      (arg1)->setCubicTexture((Ogre::TexturePtr const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_cubic_texture__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);
  {
    try {
      (arg1)->setCubicTexture((Ogre::TexturePtr const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_set_cubic_texture(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_set_cubic_texture__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_set_cubic_texture__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState.set_cubic_texture", 
    "    void TextureUnitState.set_cubic_texture(Ogre::TexturePtr const *const texPtrs, bool forUVW)\n"
    "    void TextureUnitState.set_cubic_texture(Ogre::TexturePtr const *const texPtrs)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_animated_texture_name

  call-seq:
    set_animated_texture_name(String name, unsigned int numFrames, Real duration=0)
    set_animated_texture_name(String name, unsigned int numFrames)
    set_animated_texture_name(String names, unsigned int numFrames, Real duration=0)
    set_animated_texture_name(String names, unsigned int numFrames)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_animated_texture_name__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);
  {
    try {
      (arg1)->setAnimatedTextureName((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_animated_texture_name__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);
  {
    try {
      (arg1)->setAnimatedTextureName((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_animated_texture_name__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);
  {
    try {
      (arg1)->setAnimatedTextureName((Ogre::String const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_animated_texture_name__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);
  {
    try {
      (arg1)->setAnimatedTextureName((Ogre::String const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_set_animated_texture_name(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_set_animated_texture_name__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_set_animated_texture_name__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_set_animated_texture_name__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_set_animated_texture_name__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TextureUnitState.set_animated_texture_name", 
    "    void TextureUnitState.set_animated_texture_name(Ogre::String const &name, unsigned int numFrames, Ogre::Real duration)\n"
    "    void TextureUnitState.set_animated_texture_name(Ogre::String const &name, unsigned int numFrames)\n"
    "    void TextureUnitState.set_animated_texture_name(Ogre::String const *const names, unsigned int numFrames, Ogre::Real duration)\n"
    "    void TextureUnitState.set_animated_texture_name(Ogre::String const *const names, unsigned int numFrames)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_dimensions

  call-seq:
    get_texture_dimensions(unsigned int frame=0) -> std::pair<(size_t,size_t)>
    get_texture_dimensions -> std::pair<(size_t,size_t)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_dimensions__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);
  {
    try {
      result = ((Ogre::TextureUnitState const *)arg1)->getTextureDimensions(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::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_get_texture_dimensions__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);
  {
    try {
      result = ((Ogre::TextureUnitState const *)arg1)->getTextureDimensions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::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_get_texture_dimensions(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_get_texture_dimensions__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_get_texture_dimensions__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TextureUnitState.get_texture_dimensions", 
    "    std::pair< size_t,size_t > TextureUnitState.get_texture_dimensions(unsigned int frame)\n"
    "    std::pair< size_t,size_t > TextureUnitState.get_texture_dimensions()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_current_frame

  call-seq:
    set_current_frame(unsigned int frameNumber)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_current_frame(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);
  {
    try {
      (arg1)->setCurrentFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_current_frame

  call-seq:
    get_current_frame -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_current_frame(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);
  {
    try {
      result = (unsigned int)((Ogre::TextureUnitState const *)arg1)->getCurrentFrame();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_frame_texture_name

  call-seq:
    get_frame_texture_name(unsigned int frameNumber) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_frame_texture_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::TextureUnitState const *)arg1)->getFrameTextureName(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_frame_texture_name

  call-seq:
    set_frame_texture_name(String name, unsigned int frameNumber)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_frame_texture_name(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);
  {
    try {
      (arg1)->setFrameTextureName((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.add_frame_texture_name

  call-seq:
    add_frame_texture_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_add_frame_texture_name(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;
  }
  {
    try {
      (arg1)->addFrameTextureName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.delete_frame_texture_name

  call-seq:
    delete_frame_texture_name(size_t frameNumber)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_delete_frame_texture_name(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);
  {
    try {
      (arg1)->deleteFrameTextureName(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_num_frames

  call-seq:
    get_num_frames -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_num_frames(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);
  {
    try {
      result = (unsigned int)((Ogre::TextureUnitState const *)arg1)->getNumFrames();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BindingType.BT_FRAGMENT

  call-seq:
    BT_FRAGMENT -> int

A class method.

*/

/*
  Document-method: Ogre::BindingType.BT_VERTEX

  call-seq:
    BT_VERTEX -> int

A class method.

*/

/*
  Document-method: Ogre::ContentType.CONTENT_NAMED

  call-seq:
    CONTENT_NAMED -> int

A class method.

*/

/*
  Document-method: Ogre::ContentType.CONTENT_SHADOW

  call-seq:
    CONTENT_SHADOW -> int

A class method.

*/

/*
  Document-method: Ogre::ContentType.CONTENT_COMPOSITOR

  call-seq:
    CONTENT_COMPOSITOR -> int

A class method.

*/

/*
  Document-method: Ogre::TextureUnitState.set_binding_type

  call-seq:
    set_binding_type(BindingType bt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_binding_type(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);
  {
    try {
      (arg1)->setBindingType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_binding_type

  call-seq:
    get_binding_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_binding_type(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);
  {
    try {
      result = (Ogre::TextureUnitState::BindingType)((Ogre::TextureUnitState const *)arg1)->getBindingType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_content_type

  call-seq:
    set_content_type(ContentType ct)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_content_type(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);
  {
    try {
      (arg1)->setContentType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_content_type

  call-seq:
    get_content_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_content_type(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);
  {
    try {
      result = (Ogre::TextureUnitState::ContentType)((Ogre::TextureUnitState const *)arg1)->getContentType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.is_cubic

  call-seq:
    is_cubic -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_is_cubic(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);
  {
    try {
      result = (bool)((Ogre::TextureUnitState const *)arg1)->isCubic();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.is_3d

  call-seq:
    is_3d -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_is_3d(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);
  {
    try {
      result = (bool)((Ogre::TextureUnitState const *)arg1)->is3D();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_type

  call-seq:
    get_texture_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_type(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);
  {
    try {
      result = (Ogre::TextureType)((Ogre::TextureUnitState const *)arg1)->getTextureType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_desired_format

  call-seq:
    set_desired_format(PixelFormat desiredFormat)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_desired_format(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);
  {
    try {
      (arg1)->setDesiredFormat(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_desired_format

  call-seq:
    get_desired_format -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_desired_format(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);
  {
    try {
      result = (Ogre::PixelFormat)((Ogre::TextureUnitState const *)arg1)->getDesiredFormat();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_num_mipmaps

  call-seq:
    set_num_mipmaps(int numMipmaps)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_num_mipmaps(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);
  {
    try {
      (arg1)->setNumMipmaps(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_num_mipmaps

  call-seq:
    get_num_mipmaps -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_num_mipmaps(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);
  {
    try {
      result = (int)((Ogre::TextureUnitState const *)arg1)->getNumMipmaps();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_is_alpha

  call-seq:
    set_is_alpha(bool isAlpha)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_is_alpha(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);
  {
    try {
      (arg1)->setIsAlpha(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_is_alpha

  call-seq:
    get_is_alpha -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_is_alpha(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);
  {
    try {
      result = (bool)((Ogre::TextureUnitState const *)arg1)->getIsAlpha();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_hardware_gamma_enabled

  call-seq:
    set_hardware_gamma_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_hardware_gamma_enabled(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);
  {
    try {
      (arg1)->setHardwareGammaEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.is_hardware_gamma_enabled

  call-seq:
    is_hardware_gamma_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_is_hardware_gamma_enabled(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);
  {
    try {
      result = (bool)((Ogre::TextureUnitState const *)arg1)->isHardwareGammaEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_coord_set

  call-seq:
    get_texture_coord_set -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_coord_set(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);
  {
    try {
      result = (unsigned int)((Ogre::TextureUnitState const *)arg1)->getTextureCoordSet();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_coord_set

  call-seq:
    set_texture_coord_set(unsigned int set)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_coord_set(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);
  {
    try {
      (arg1)->setTextureCoordSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_transform

  call-seq:
    set_texture_transform(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_transform(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);
  {
    try {
      (arg1)->setTextureTransform((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_transform

  call-seq:
    get_texture_transform -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_transform(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::TextureUnitState const *)arg1)->getTextureTransform();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_scroll

  call-seq:
    set_texture_scroll(Real u, Real v)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_scroll(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);
  {
    try {
      (arg1)->setTextureScroll(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_uscroll

  call-seq:
    set_texture_uscroll(Real value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_uscroll(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);
  {
    try {
      (arg1)->setTextureUScroll(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_uscroll

  call-seq:
    get_texture_uscroll -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_uscroll(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TextureUnitState const *)arg1)->getTextureUScroll();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_vscroll

  call-seq:
    set_texture_vscroll(Real value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_vscroll(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);
  {
    try {
      (arg1)->setTextureVScroll(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_vscroll

  call-seq:
    get_texture_vscroll -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_vscroll(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TextureUnitState const *)arg1)->getTextureVScroll();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_uscale

  call-seq:
    set_texture_uscale(Real value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_uscale(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);
  {
    try {
      (arg1)->setTextureUScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_uscale

  call-seq:
    get_texture_uscale -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_uscale(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TextureUnitState const *)arg1)->getTextureUScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_vscale

  call-seq:
    set_texture_vscale(Real value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_vscale(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);
  {
    try {
      (arg1)->setTextureVScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_vscale

  call-seq:
    get_texture_vscale -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_vscale(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TextureUnitState const *)arg1)->getTextureVScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_scale

  call-seq:
    set_texture_scale(Real uScale, Real vScale)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_scale(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);
  {
    try {
      (arg1)->setTextureScale(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_rotate

  call-seq:
    set_texture_rotate(Radian angle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_rotate(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);
  {
    try {
      (arg1)->setTextureRotate((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_rotate

  call-seq:
    get_texture_rotate -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_rotate(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);
  {
    try {
      result = (Ogre::Radian *) &((Ogre::TextureUnitState const *)arg1)->getTextureRotate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_addressing_mode

  call-seq:
    get_texture_addressing_mode -> UVWAddressingMode

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_addressing_mode(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);
  {
    try {
      result = (Ogre::TextureUnitState::UVWAddressingMode *) &((Ogre::TextureUnitState const *)arg1)->getTextureAddressingMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState__UVWAddressingMode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_addressing_mode

  call-seq:
    set_texture_addressing_mode(TextureAddressingMode tam)
    set_texture_addressing_mode(TextureAddressingMode u, TextureAddressingMode v, TextureAddressingMode w)
    set_texture_addressing_mode(UVWAddressingMode uvw)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_addressing_mode__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);
  {
    try {
      (arg1)->setTextureAddressingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_addressing_mode__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);
  {
    try {
      (arg1)->setTextureAddressingMode(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_addressing_mode__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);
  {
    try {
      (arg1)->setTextureAddressingMode((Ogre::TextureUnitState::UVWAddressingMode const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_set_texture_addressing_mode(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_set_texture_addressing_mode__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_set_texture_addressing_mode__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_set_texture_addressing_mode__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TextureUnitState.set_texture_addressing_mode", 
    "    void TextureUnitState.set_texture_addressing_mode(Ogre::TextureUnitState::TextureAddressingMode tam)\n"
    "    void TextureUnitState.set_texture_addressing_mode(Ogre::TextureUnitState::TextureAddressingMode u, Ogre::TextureUnitState::TextureAddressingMode v, Ogre::TextureUnitState::TextureAddressingMode w)\n"
    "    void TextureUnitState.set_texture_addressing_mode(Ogre::TextureUnitState::UVWAddressingMode const &uvw)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_border_colour

  call-seq:
    set_texture_border_colour(ColourValue colour)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_border_colour(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);
  {
    try {
      (arg1)->setTextureBorderColour((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_border_colour

  call-seq:
    get_texture_border_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_border_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::TextureUnitState const *)arg1)->getTextureBorderColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_colour_operation_ex

  call-seq:
    set_colour_operation_ex(LayerBlendOperationEx op, LayerBlendSource source1=LBS_TEXTURE, 
    LayerBlendSource source2=LBS_CURRENT, 
    ColourValue arg1=White, ColourValue arg2=White, 
    Real manualBlend=0.0)
    set_colour_operation_ex(LayerBlendOperationEx op, LayerBlendSource source1=LBS_TEXTURE, 
    LayerBlendSource source2=LBS_CURRENT, 
    ColourValue arg1=White, ColourValue arg2=White)
    set_colour_operation_ex(LayerBlendOperationEx op, LayerBlendSource source1=LBS_TEXTURE, 
    LayerBlendSource source2=LBS_CURRENT, 
    ColourValue arg1=White)
    set_colour_operation_ex(LayerBlendOperationEx op, LayerBlendSource source1=LBS_TEXTURE, 
    LayerBlendSource source2=LBS_CURRENT)
    set_colour_operation_ex(LayerBlendOperationEx op, LayerBlendSource source1=LBS_TEXTURE)
    set_colour_operation_ex(LayerBlendOperationEx op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_colour_operation_ex__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);
  {
    try {
      (arg1)->setColourOperationEx(arg2,arg3,arg4,(Ogre::ColourValue const &)*arg5,(Ogre::ColourValue const &)*arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_colour_operation_ex__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);
  {
    try {
      (arg1)->setColourOperationEx(arg2,arg3,arg4,(Ogre::ColourValue const &)*arg5,(Ogre::ColourValue const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_colour_operation_ex__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);
  {
    try {
      (arg1)->setColourOperationEx(arg2,arg3,arg4,(Ogre::ColourValue const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_colour_operation_ex__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);
  {
    try {
      (arg1)->setColourOperationEx(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_colour_operation_ex__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);
  {
    try {
      (arg1)->setColourOperationEx(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_colour_operation_ex__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);
  {
    try {
      (arg1)->setColourOperationEx(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_set_colour_operation_ex(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_set_colour_operation_ex__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_set_colour_operation_ex__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_set_colour_operation_ex__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_set_colour_operation_ex__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_set_colour_operation_ex__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_set_colour_operation_ex__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "TextureUnitState.set_colour_operation_ex", 
    "    void TextureUnitState.set_colour_operation_ex(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2, Ogre::ColourValue const &arg1, Ogre::ColourValue const &arg2, Ogre::Real manualBlend)\n"
    "    void TextureUnitState.set_colour_operation_ex(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2, Ogre::ColourValue const &arg1, Ogre::ColourValue const &arg2)\n"
    "    void TextureUnitState.set_colour_operation_ex(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2, Ogre::ColourValue const &arg1)\n"
    "    void TextureUnitState.set_colour_operation_ex(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2)\n"
    "    void TextureUnitState.set_colour_operation_ex(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1)\n"
    "    void TextureUnitState.set_colour_operation_ex(Ogre::LayerBlendOperationEx op)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_colour_operation

  call-seq:
    set_colour_operation(LayerBlendOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_colour_operation(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);
  {
    try {
      (arg1)->setColourOperation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_colour_op_multipass_fallback

  call-seq:
    set_colour_op_multipass_fallback(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_colour_op_multipass_fallback(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);
  {
    try {
      (arg1)->setColourOpMultipassFallback(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_colour_blend_mode

  call-seq:
    get_colour_blend_mode -> LayerBlendModeEx

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_colour_blend_mode(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);
  {
    try {
      result = (Ogre::LayerBlendModeEx *) &((Ogre::TextureUnitState const *)arg1)->getColourBlendMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LayerBlendModeEx, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_alpha_blend_mode

  call-seq:
    get_alpha_blend_mode -> LayerBlendModeEx

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_alpha_blend_mode(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);
  {
    try {
      result = (Ogre::LayerBlendModeEx *) &((Ogre::TextureUnitState const *)arg1)->getAlphaBlendMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LayerBlendModeEx, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_colour_blend_fallback_src

  call-seq:
    get_colour_blend_fallback_src -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_colour_blend_fallback_src(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);
  {
    try {
      result = (Ogre::SceneBlendFactor)((Ogre::TextureUnitState const *)arg1)->getColourBlendFallbackSrc();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_colour_blend_fallback_dest

  call-seq:
    get_colour_blend_fallback_dest -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_colour_blend_fallback_dest(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);
  {
    try {
      result = (Ogre::SceneBlendFactor)((Ogre::TextureUnitState const *)arg1)->getColourBlendFallbackDest();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_alpha_operation

  call-seq:
    set_alpha_operation(LayerBlendOperationEx op, LayerBlendSource source1=LBS_TEXTURE, 
    LayerBlendSource source2=LBS_CURRENT, 
    Real arg1=1.0, Real arg2=1.0, Real manualBlend=0.0)
    set_alpha_operation(LayerBlendOperationEx op, LayerBlendSource source1=LBS_TEXTURE, 
    LayerBlendSource source2=LBS_CURRENT, 
    Real arg1=1.0, Real arg2=1.0)
    set_alpha_operation(LayerBlendOperationEx op, LayerBlendSource source1=LBS_TEXTURE, 
    LayerBlendSource source2=LBS_CURRENT, 
    Real arg1=1.0)
    set_alpha_operation(LayerBlendOperationEx op, LayerBlendSource source1=LBS_TEXTURE, 
    LayerBlendSource source2=LBS_CURRENT)
    set_alpha_operation(LayerBlendOperationEx op, LayerBlendSource source1=LBS_TEXTURE)
    set_alpha_operation(LayerBlendOperationEx op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_alpha_operation__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);
  {
    try {
      (arg1)->setAlphaOperation(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_alpha_operation__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);
  {
    try {
      (arg1)->setAlphaOperation(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_alpha_operation__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);
  {
    try {
      (arg1)->setAlphaOperation(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_alpha_operation__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);
  {
    try {
      (arg1)->setAlphaOperation(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_alpha_operation__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);
  {
    try {
      (arg1)->setAlphaOperation(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_alpha_operation__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);
  {
    try {
      (arg1)->setAlphaOperation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_set_alpha_operation(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_set_alpha_operation__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_set_alpha_operation__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_set_alpha_operation__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_set_alpha_operation__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_set_alpha_operation__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_set_alpha_operation__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "TextureUnitState.set_alpha_operation", 
    "    void TextureUnitState.set_alpha_operation(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2, Ogre::Real arg1, Ogre::Real arg2, Ogre::Real manualBlend)\n"
    "    void TextureUnitState.set_alpha_operation(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2, Ogre::Real arg1, Ogre::Real arg2)\n"
    "    void TextureUnitState.set_alpha_operation(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2, Ogre::Real arg1)\n"
    "    void TextureUnitState.set_alpha_operation(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2)\n"
    "    void TextureUnitState.set_alpha_operation(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1)\n"
    "    void TextureUnitState.set_alpha_operation(Ogre::LayerBlendOperationEx op)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.add_effect

  call-seq:
    add_effect(TextureEffect effect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_add_effect(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);
  {
    try {
      (arg1)->addEffect(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_environment_map

  call-seq:
    set_environment_map(bool enable, EnvMapType envMapType=ENV_CURVED)
    set_environment_map(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_environment_map__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);
  {
    try {
      (arg1)->setEnvironmentMap(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_environment_map__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);
  {
    try {
      (arg1)->setEnvironmentMap(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_set_environment_map(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_set_environment_map__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_set_environment_map__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState.set_environment_map", 
    "    void TextureUnitState.set_environment_map(bool enable, Ogre::TextureUnitState::EnvMapType envMapType)\n"
    "    void TextureUnitState.set_environment_map(bool enable)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_scroll_animation

  call-seq:
    set_scroll_animation(Real uSpeed, Real vSpeed)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_scroll_animation(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);
  {
    try {
      (arg1)->setScrollAnimation(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_rotate_animation

  call-seq:
    set_rotate_animation(Real speed)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_rotate_animation(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);
  {
    try {
      (arg1)->setRotateAnimation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_transform_animation

  call-seq:
    set_transform_animation(TextureTransformType ttype, WaveformType waveType, 
    Real base=0, Real frequency=1, Real phase=0, 
    Real amplitude=1)
    set_transform_animation(TextureTransformType ttype, WaveformType waveType, 
    Real base=0, Real frequency=1, Real phase=0)
    set_transform_animation(TextureTransformType ttype, WaveformType waveType, 
    Real base=0, Real frequency=1)
    set_transform_animation(TextureTransformType ttype, WaveformType waveType, 
    Real base=0)
    set_transform_animation(TextureTransformType ttype, WaveformType waveType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_transform_animation__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);
  {
    try {
      (arg1)->setTransformAnimation(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_transform_animation__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);
  {
    try {
      (arg1)->setTransformAnimation(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_transform_animation__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);
  {
    try {
      (arg1)->setTransformAnimation(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_transform_animation__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);
  {
    try {
      (arg1)->setTransformAnimation(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_transform_animation__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);
  {
    try {
      (arg1)->setTransformAnimation(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_set_transform_animation(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_set_transform_animation__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_set_transform_animation__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_set_transform_animation__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_set_transform_animation__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_set_transform_animation__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "TextureUnitState.set_transform_animation", 
    "    void TextureUnitState.set_transform_animation(Ogre::TextureUnitState::TextureTransformType const ttype, Ogre::WaveformType const waveType, Ogre::Real base, Ogre::Real frequency, Ogre::Real phase, Ogre::Real amplitude)\n"
    "    void TextureUnitState.set_transform_animation(Ogre::TextureUnitState::TextureTransformType const ttype, Ogre::WaveformType const waveType, Ogre::Real base, Ogre::Real frequency, Ogre::Real phase)\n"
    "    void TextureUnitState.set_transform_animation(Ogre::TextureUnitState::TextureTransformType const ttype, Ogre::WaveformType const waveType, Ogre::Real base, Ogre::Real frequency)\n"
    "    void TextureUnitState.set_transform_animation(Ogre::TextureUnitState::TextureTransformType const ttype, Ogre::WaveformType const waveType, Ogre::Real base)\n"
    "    void TextureUnitState.set_transform_animation(Ogre::TextureUnitState::TextureTransformType const ttype, Ogre::WaveformType const waveType)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_projective_texturing

  call-seq:
    set_projective_texturing(bool enabled, Frustum projectionSettings=0)
    set_projective_texturing(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_projective_texturing__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);
  {
    try {
      (arg1)->setProjectiveTexturing(arg2,(Ogre::Frustum const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_projective_texturing__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);
  {
    try {
      (arg1)->setProjectiveTexturing(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_set_projective_texturing(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_set_projective_texturing__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_set_projective_texturing__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState.set_projective_texturing", 
    "    void TextureUnitState.set_projective_texturing(bool enabled, Ogre::Frustum const *projectionSettings)\n"
    "    void TextureUnitState.set_projective_texturing(bool enabled)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.remove_all_effects

  call-seq:
    remove_all_effects

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_remove_all_effects(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);
  {
    try {
      (arg1)->removeAllEffects();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.remove_effect

  call-seq:
    remove_effect(TextureEffectType type)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_remove_effect(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);
  {
    try {
      (arg1)->removeEffect(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.is_blank

  call-seq:
    is_blank -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_is_blank(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);
  {
    try {
      result = (bool)((Ogre::TextureUnitState const *)arg1)->isBlank();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_blank

  call-seq:
    set_blank

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_blank(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);
  {
    try {
      (arg1)->setBlank();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.is_texture_load_failing

  call-seq:
    is_texture_load_failing -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_is_texture_load_failing(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);
  {
    try {
      result = (bool)((Ogre::TextureUnitState const *)arg1)->isTextureLoadFailing();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.retry_texture_load

  call-seq:
    retry_texture_load

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_retry_texture_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 *","retryTextureLoad", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  {
    try {
      (arg1)->retryTextureLoad();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_effects

  call-seq:
    get_effects -> EffectMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_effects(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);
  {
    try {
      result = (Ogre::TextureUnitState::EffectMap *) &((Ogre::TextureUnitState const *)arg1)->getEffects();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::TextureUnitState.get_animation_duration

  call-seq:
    get_animation_duration -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_animation_duration(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TextureUnitState const *)arg1)->getAnimationDuration();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_filtering

  call-seq:
    set_texture_filtering(TextureFilterOptions filterType)
    set_texture_filtering(FilterType ftype, FilterOptions opts)
    set_texture_filtering(FilterOptions minFilter, FilterOptions magFilter, FilterOptions mipFilter)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_filtering__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);
  {
    try {
      (arg1)->setTextureFiltering(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_filtering__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);
  {
    try {
      (arg1)->setTextureFiltering(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_filtering__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);
  {
    try {
      (arg1)->setTextureFiltering(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_set_texture_filtering(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_set_texture_filtering__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_set_texture_filtering__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_set_texture_filtering__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TextureUnitState.set_texture_filtering", 
    "    void TextureUnitState.set_texture_filtering(Ogre::TextureFilterOptions filterType)\n"
    "    void TextureUnitState.set_texture_filtering(Ogre::FilterType ftype, Ogre::FilterOptions opts)\n"
    "    void TextureUnitState.set_texture_filtering(Ogre::FilterOptions minFilter, Ogre::FilterOptions magFilter, Ogre::FilterOptions mipFilter)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_filtering

  call-seq:
    get_texture_filtering(FilterType ftpye) -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_filtering(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);
  {
    try {
      result = (Ogre::FilterOptions)((Ogre::TextureUnitState const *)arg1)->getTextureFiltering(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_anisotropy

  call-seq:
    set_texture_anisotropy(unsigned int maxAniso)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_anisotropy(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);
  {
    try {
      (arg1)->setTextureAnisotropy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_anisotropy

  call-seq:
    get_texture_anisotropy -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_anisotropy(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);
  {
    try {
      result = (unsigned int)((Ogre::TextureUnitState const *)arg1)->getTextureAnisotropy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_mipmap_bias

  call-seq:
    set_texture_mipmap_bias(float bias)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_mipmap_bias(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);
  {
    try {
      (arg1)->setTextureMipmapBias(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_mipmap_bias

  call-seq:
    get_texture_mipmap_bias -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_mipmap_bias(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);
  {
    try {
      result = (float)((Ogre::TextureUnitState const *)arg1)->getTextureMipmapBias();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_compositor_reference

  call-seq:
    set_compositor_reference(String compositorName, String textureName, size_t mrtIndex=0)
    set_compositor_reference(String compositorName, String textureName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_compositor_reference__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);
  {
    try {
      (arg1)->setCompositorReference((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_set_compositor_reference__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;
  }
  {
    try {
      (arg1)->setCompositorReference((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_set_compositor_reference(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_set_compositor_reference__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_set_compositor_reference__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TextureUnitState.set_compositor_reference", 
    "    void TextureUnitState.set_compositor_reference(Ogre::String const &compositorName, Ogre::String const &textureName, size_t mrtIndex)\n"
    "    void TextureUnitState.set_compositor_reference(Ogre::String const &compositorName, Ogre::String const &textureName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_referenced_compositor_name

  call-seq:
    get_referenced_compositor_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_referenced_compositor_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::TextureUnitState const *)arg1)->getReferencedCompositorName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_referenced_texture_name

  call-seq:
    get_referenced_texture_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_referenced_texture_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::TextureUnitState const *)arg1)->getReferencedTextureName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_referenced_mrtindex

  call-seq:
    get_referenced_mrtindex -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_referenced_mrtindex(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);
  {
    try {
      result = ((Ogre::TextureUnitState const *)arg1)->getReferencedMRTIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_parent

  call-seq:
    get_parent -> Pass

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_parent(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);
  {
    try {
      result = (Ogre::Pass *)((Ogre::TextureUnitState const *)arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState._prepare

  call-seq:
    _prepare

An instance method.

*/
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);
  {
    try {
      (arg1)->_prepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState._unprepare

  call-seq:
    _unprepare

An instance method.

*/
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);
  {
    try {
      (arg1)->_unprepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState._load

  call-seq:
    _load

An instance method.

*/
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);
  {
    try {
      (arg1)->_load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState._unload

  call-seq:
    _unload

An instance method.

*/
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);
  {
    try {
      (arg1)->_unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.has_view_relative_texture_coordinate_generation

  call-seq:
    has_view_relative_texture_coordinate_generation -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_has_view_relative_texture_coordinate_generation(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);
  {
    try {
      result = (bool)((Ogre::TextureUnitState const *)arg1)->hasViewRelativeTextureCoordinateGeneration();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.is_loaded

  call-seq:
    is_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_is_loaded(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);
  {
    try {
      result = (bool)((Ogre::TextureUnitState const *)arg1)->isLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState._notify_needs_recompile

  call-seq:
    _notify_needs_recompile

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState__notify_needs_recompile(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);
  {
    try {
      (arg1)->_notifyNeedsRecompile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_name

  call-seq:
    set_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_name(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;
  }
  {
    try {
      (arg1)->setName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::TextureUnitState const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.set_texture_name_alias

  call-seq:
    set_texture_name_alias(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_set_texture_name_alias(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;
  }
  {
    try {
      (arg1)->setTextureNameAlias((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.get_texture_name_alias

  call-seq:
    get_texture_name_alias -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_get_texture_name_alias(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::TextureUnitState const *)arg1)->getTextureNameAlias();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState.apply_texture_aliases

  call-seq:
    apply_texture_aliases(AliasTextureNamePairList aliasList, bool apply=true) -> bool
    apply_texture_aliases(AliasTextureNamePairList aliasList) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState_apply_texture_aliases__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);
  {
    try {
      result = (bool)(arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_apply_texture_aliases__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);
  {
    try {
      result = (bool)(arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_apply_texture_aliases(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_apply_texture_aliases__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_apply_texture_aliases__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState.apply_texture_aliases", 
    "    bool TextureUnitState.apply_texture_aliases(Ogre::AliasTextureNamePairList const &aliasList, bool const apply)\n"
    "    bool TextureUnitState.apply_texture_aliases(Ogre::AliasTextureNamePairList const &aliasList)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState._notify_parent

  call-seq:
    _notify_parent(Pass parent)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState__notify_parent(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);
  {
    try {
      (arg1)->_notifyParent(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState._get_texture_ptr

  call-seq:
    _get_texture_ptr -> TexturePtr
    _get_texture_ptr(size_t frame) -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState__get_texture_ptr__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);
  {
    try {
      result = (Ogre::TexturePtr *) &((Ogre::TextureUnitState const *)arg1)->_getTexturePtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__get_texture_ptr__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);
  {
    try {
      result = (Ogre::TexturePtr *) &((Ogre::TextureUnitState const *)arg1)->_getTexturePtr(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState__get_texture_ptr(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__get_texture_ptr__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__get_texture_ptr__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TextureUnitState._get_texture_ptr", 
    "    Ogre::TexturePtr const & TextureUnitState._get_texture_ptr()\n"
    "    Ogre::TexturePtr const & TextureUnitState._get_texture_ptr(size_t frame)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState._set_texture_ptr

  call-seq:
    _set_texture_ptr(TexturePtr texptr)
    _set_texture_ptr(TexturePtr texptr, size_t frame)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState__set_texture_ptr__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);
  {
    try {
      (arg1)->_setTexturePtr((Ogre::TexturePtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__set_texture_ptr__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);
  {
    try {
      (arg1)->_setTexturePtr((Ogre::TexturePtr const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState__set_texture_ptr(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__set_texture_ptr__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__set_texture_ptr__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState._set_texture_ptr", 
    "    void TextureUnitState._set_texture_ptr(Ogre::TexturePtr const &texptr)\n"
    "    void TextureUnitState._set_texture_ptr(Ogre::TexturePtr const &texptr, size_t frame)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitState._get_anim_controller

  call-seq:
    _get_anim_controller -> Ogre::Controller<(Ogre::Real)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureUnitState__get_anim_controller(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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)((Ogre::TextureUnitState const *)arg1)->_getAnimController();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::MaterialScriptProgramDefinition

  Proxy of C++ Ogre::MaterialScriptProgramDefinition class


*/
swig_class SwigClassMaterialScriptProgramDefinition;


/*
  Document-method: Ogre::MaterialScriptProgramDefinition.name

  call-seq:
    name -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptProgramDefinition.name=

  call-seq:
    name=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptProgramDefinition.progType

  call-seq:
    progType -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptProgramDefinition.progType=

  call-seq:
    progType=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptProgramDefinition.language

  call-seq:
    language -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptProgramDefinition.language=

  call-seq:
    language=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptProgramDefinition.source

  call-seq:
    source -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptProgramDefinition.source=

  call-seq:
    source=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptProgramDefinition.syntax

  call-seq:
    syntax -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptProgramDefinition.syntax=

  call-seq:
    syntax=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptProgramDefinition.supportsSkeletalAnimation

  call-seq:
    supportsSkeletalAnimation -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptProgramDefinition.supportsSkeletalAnimation=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptProgramDefinition.supportsMorphAnimation

  call-seq:
    supportsMorphAnimation -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptProgramDefinition.supportsMorphAnimation=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptProgramDefinition.supportsPoseAnimation

  call-seq:
    supportsPoseAnimation -> ushort

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptProgramDefinition.supportsPoseAnimation=

  call-seq:
    supportsPoseAnimation=(x) -> ushort

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptProgramDefinition.usesVertexTextureFetch

  call-seq:
    usesVertexTextureFetch -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptProgramDefinition.usesVertexTextureFetch=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptProgramDefinition.customParameters

  call-seq:
    customParameters -> Ogre::vector<(std::pair<(Ogre::String,Ogre::String)>,Ogre::STLAllocator<(std::pair<(Ogre::String,Ogre::String)>,Ogre::GeneralAllocPolicy)>)>::type

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptProgramDefinition.customParameters=

  call-seq:
    customParameters=(x) -> Ogre::vector<(std::pair<(Ogre::String,Ogre::String)>,Ogre::STLAllocator<(std::pair<(Ogre::String,Ogre::String)>,Ogre::GeneralAllocPolicy)>)>::type

Set new value for attribute.

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


/*
  Document-method: Ogre::MaterialScriptProgramDefinition.new

  call-seq:
    MaterialScriptProgramDefinition.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::MaterialScriptProgramDefinition *)new Ogre::MaterialScriptProgramDefinition();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MaterialScriptProgramDefinition(Ogre::MaterialScriptProgramDefinition *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::MaterialScriptContext

  Proxy of C++ Ogre::MaterialScriptContext class


*/
swig_class SwigClassMaterialScriptContext;


/*
  Document-method: Ogre::MaterialScriptContext.section

  call-seq:
    section -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.section=

  call-seq:
    section=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.groupName

  call-seq:
    groupName -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.groupName=

  call-seq:
    groupName=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.material

  call-seq:
    material -> MaterialPtr

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.material=

  call-seq:
    material=(x) -> MaterialPtr

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.technique

  call-seq:
    technique -> Technique

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.technique=

  call-seq:
    technique=(x) -> Technique

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.pass

  call-seq:
    pass -> Pass

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.pass=

  call-seq:
    pass=(x) -> Pass

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.textureUnit

  call-seq:
    textureUnit -> TextureUnitState

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.textureUnit=

  call-seq:
    textureUnit=(x) -> TextureUnitState

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.program

  call-seq:
    program -> GpuProgramPtr

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.program=

  call-seq:
    program=(x) -> GpuProgramPtr

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.isVertexProgramShadowCaster

  call-seq:
    isVertexProgramShadowCaster -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.isVertexProgramShadowCaster=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.isFragmentProgramShadowCaster

  call-seq:
    isFragmentProgramShadowCaster -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.isFragmentProgramShadowCaster=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.isVertexProgramShadowReceiver

  call-seq:
    isVertexProgramShadowReceiver -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.isVertexProgramShadowReceiver=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.isFragmentProgramShadowReceiver

  call-seq:
    isFragmentProgramShadowReceiver -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.isFragmentProgramShadowReceiver=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.programParams

  call-seq:
    programParams -> GpuProgramParametersSharedPtr

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.programParams=

  call-seq:
    programParams=(x) -> GpuProgramParametersSharedPtr

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.numAnimationParametrics

  call-seq:
    numAnimationParametrics -> ushort

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.numAnimationParametrics=

  call-seq:
    numAnimationParametrics=(x) -> ushort

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.programDef

  call-seq:
    programDef -> MaterialScriptProgramDefinition

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.programDef=

  call-seq:
    programDef=(x) -> MaterialScriptProgramDefinition

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.techLev

  call-seq:
    techLev -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.techLev=

  call-seq:
    techLev=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.passLev

  call-seq:
    passLev -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.passLev=

  call-seq:
    passLev=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.stateLev

  call-seq:
    stateLev -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.stateLev=

  call-seq:
    stateLev=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.defaultParamLines

  call-seq:
    defaultParamLines -> StringVector

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.defaultParamLines=

  call-seq:
    defaultParamLines=(x) -> StringVector

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.lineNo

  call-seq:
    lineNo -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.lineNo=

  call-seq:
    lineNo=(x) -> size_t

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.filename

  call-seq:
    filename -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.filename=

  call-seq:
    filename=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::MaterialScriptContext.textureAliases

  call-seq:
    textureAliases -> AliasTextureNamePairList

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialScriptContext.textureAliases=

  call-seq:
    textureAliases=(x) -> AliasTextureNamePairList

Set new value for attribute.

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


/*
  Document-method: Ogre::MaterialScriptContext.new

  call-seq:
    MaterialScriptContext.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::MaterialScriptContext *)new Ogre::MaterialScriptContext();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MaterialScriptContext(Ogre::MaterialScriptContext *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::MaterialSerializer

  Proxy of C++ Ogre::MaterialSerializer class


*/
swig_class SwigClassMaterialSerializer;


/*
  Document-method: Ogre::SerializeEvent.MSE_PRE_WRITE

  call-seq:
    MSE_PRE_WRITE -> int

A class method.

*/

/*
  Document-method: Ogre::SerializeEvent.MSE_WRITE_BEGIN

  call-seq:
    MSE_WRITE_BEGIN -> int

A class method.

*/

/*
  Document-method: Ogre::SerializeEvent.MSE_WRITE_END

  call-seq:
    MSE_WRITE_END -> int

A class method.

*/

/*
  Document-method: Ogre::SerializeEvent.MSE_POST_WRITE

  call-seq:
    MSE_POST_WRITE -> int

A class method.

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


/*
  Document-method: Ogre::MaterialSerializer.new

  call-seq:
    MaterialSerializer.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::MaterialSerializer *)new Ogre::MaterialSerializer();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MaterialSerializer(Ogre::MaterialSerializer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::MaterialSerializer.queue_for_export

  call-seq:
    queue_for_export(MaterialPtr pMat, bool clearQueued=false, bool exportDefaults=false, 
    String materialName="")
    queue_for_export(MaterialPtr pMat, bool clearQueued=false, bool exportDefaults=false)
    queue_for_export(MaterialPtr pMat, bool clearQueued=false)
    queue_for_export(MaterialPtr pMat)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_queue_for_export__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;
  }
  {
    try {
      (arg1)->queueForExport((Ogre::MaterialPtr const &)*arg2,arg3,arg4,(Ogre::String const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_queue_for_export__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);
  {
    try {
      (arg1)->queueForExport((Ogre::MaterialPtr const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_queue_for_export__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);
  {
    try {
      (arg1)->queueForExport((Ogre::MaterialPtr const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_queue_for_export__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);
  {
    try {
      (arg1)->queueForExport((Ogre::MaterialPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_queue_for_export(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_queue_for_export__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_queue_for_export__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_queue_for_export__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_queue_for_export__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "MaterialSerializer.queue_for_export", 
    "    void MaterialSerializer.queue_for_export(Ogre::MaterialPtr const &pMat, bool clearQueued, bool exportDefaults, Ogre::String const &materialName)\n"
    "    void MaterialSerializer.queue_for_export(Ogre::MaterialPtr const &pMat, bool clearQueued, bool exportDefaults)\n"
    "    void MaterialSerializer.queue_for_export(Ogre::MaterialPtr const &pMat, bool clearQueued)\n"
    "    void MaterialSerializer.queue_for_export(Ogre::MaterialPtr const &pMat)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSerializer.export_queued

  call-seq:
    export_queued(String filename, bool includeProgDef=false, String programFilename="")
    export_queued(String filename, bool includeProgDef=false)
    export_queued(String filename)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_export_queued__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;
  }
  {
    try {
      (arg1)->exportQueued((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_export_queued__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);
  {
    try {
      (arg1)->exportQueued((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_export_queued__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;
  }
  {
    try {
      (arg1)->exportQueued((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_export_queued(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_export_queued__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_export_queued__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_export_queued__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MaterialSerializer.export_queued", 
    "    void MaterialSerializer.export_queued(Ogre::String const &filename, bool const includeProgDef, Ogre::String const &programFilename)\n"
    "    void MaterialSerializer.export_queued(Ogre::String const &filename, bool const includeProgDef)\n"
    "    void MaterialSerializer.export_queued(Ogre::String const &filename)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSerializer.export_material

  call-seq:
    export_material(MaterialPtr pMat, String filename, bool exportDefaults=false, 
    bool includeProgDef=false, String programFilename="", 
    String materialName="")
    export_material(MaterialPtr pMat, String filename, bool exportDefaults=false, 
    bool includeProgDef=false, String programFilename="")
    export_material(MaterialPtr pMat, String filename, bool exportDefaults=false, 
    bool includeProgDef=false)
    export_material(MaterialPtr pMat, String filename, bool exportDefaults=false)
    export_material(MaterialPtr pMat, String filename)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_export_material__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;
  }
  {
    try {
      (arg1)->exportMaterial((Ogre::MaterialPtr const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::String const &)*arg6,(Ogre::String const &)*arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_export_material__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;
  }
  {
    try {
      (arg1)->exportMaterial((Ogre::MaterialPtr const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::String const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_export_material__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);
  {
    try {
      (arg1)->exportMaterial((Ogre::MaterialPtr const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_export_material__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);
  {
    try {
      (arg1)->exportMaterial((Ogre::MaterialPtr const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_export_material__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;
  }
  {
    try {
      (arg1)->exportMaterial((Ogre::MaterialPtr const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_export_material(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_export_material__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_export_material__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_export_material__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_export_material__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_export_material__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "MaterialSerializer.export_material", 
    "    void MaterialSerializer.export_material(Ogre::MaterialPtr const &pMat, Ogre::String const &filename, bool exportDefaults, bool const includeProgDef, Ogre::String const &programFilename, Ogre::String const &materialName)\n"
    "    void MaterialSerializer.export_material(Ogre::MaterialPtr const &pMat, Ogre::String const &filename, bool exportDefaults, bool const includeProgDef, Ogre::String const &programFilename)\n"
    "    void MaterialSerializer.export_material(Ogre::MaterialPtr const &pMat, Ogre::String const &filename, bool exportDefaults, bool const includeProgDef)\n"
    "    void MaterialSerializer.export_material(Ogre::MaterialPtr const &pMat, Ogre::String const &filename, bool exportDefaults)\n"
    "    void MaterialSerializer.export_material(Ogre::MaterialPtr const &pMat, Ogre::String const &filename)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSerializer.get_queued_as_string

  call-seq:
    get_queued_as_string -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_get_queued_as_string(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::MaterialSerializer const *)arg1)->getQueuedAsString();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSerializer.clear_queue

  call-seq:
    clear_queue

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_clear_queue(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);
  {
    try {
      (arg1)->clearQueue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSerializer.parse_script

  call-seq:
    parse_script(DataStreamPtr stream, String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_parse_script(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;
  }
  {
    try {
      (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSerializer.add_listener

  call-seq:
    add_listener(Listener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_add_listener(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);
  {
    try {
      (arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSerializer.remove_listener

  call-seq:
    remove_listener(Listener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_remove_listener(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);
  {
    try {
      (arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSerializer.begin_section

  call-seq:
    begin_section(unsigned short level, bool useMainBuffer=true)
    begin_section(unsigned short level)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_begin_section__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);
  {
    try {
      (arg1)->beginSection(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_begin_section__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);
  {
    try {
      (arg1)->beginSection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_begin_section(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_begin_section__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_begin_section__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MaterialSerializer.begin_section", 
    "    void MaterialSerializer.begin_section(unsigned short level, bool const useMainBuffer)\n"
    "    void MaterialSerializer.begin_section(unsigned short level)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSerializer.end_section

  call-seq:
    end_section(unsigned short level, bool useMainBuffer=true)
    end_section(unsigned short level)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_end_section__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);
  {
    try {
      (arg1)->endSection(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_end_section__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);
  {
    try {
      (arg1)->endSection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_end_section(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_end_section__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_end_section__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MaterialSerializer.end_section", 
    "    void MaterialSerializer.end_section(unsigned short level, bool const useMainBuffer)\n"
    "    void MaterialSerializer.end_section(unsigned short level)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSerializer.write_attribute

  call-seq:
    write_attribute(unsigned short level, String att, bool useMainBuffer=true)
    write_attribute(unsigned short level, String att)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_write_attribute__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);
  {
    try {
      (arg1)->writeAttribute(arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_write_attribute__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;
  }
  {
    try {
      (arg1)->writeAttribute(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_write_attribute(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_write_attribute__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_write_attribute__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MaterialSerializer.write_attribute", 
    "    void MaterialSerializer.write_attribute(unsigned short level, Ogre::String const &att, bool const useMainBuffer)\n"
    "    void MaterialSerializer.write_attribute(unsigned short level, Ogre::String const &att)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSerializer.write_value

  call-seq:
    write_value(String val, bool useMainBuffer=true)
    write_value(String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_write_value__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);
  {
    try {
      (arg1)->writeValue((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_write_value__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;
  }
  {
    try {
      (arg1)->writeValue((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_write_value(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_write_value__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_write_value__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MaterialSerializer.write_value", 
    "    void MaterialSerializer.write_value(Ogre::String const &val, bool const useMainBuffer)\n"
    "    void MaterialSerializer.write_value(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MaterialSerializer.quote_word

  call-seq:
    quote_word(String val) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_quote_word(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;
  }
  {
    try {
      result = (arg1)->quoteWord((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::MaterialSerializer.write_comment

  call-seq:
    write_comment(unsigned short level, String comment, bool useMainBuffer=true)
    write_comment(unsigned short level, String comment)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialSerializer_write_comment__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);
  {
    try {
      (arg1)->writeComment(arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_write_comment__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;
  }
  {
    try {
      (arg1)->writeComment(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_write_comment(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_write_comment__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_write_comment__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MaterialSerializer.write_comment", 
    "    void MaterialSerializer.write_comment(unsigned short level, Ogre::String const &comment, bool const useMainBuffer)\n"
    "    void MaterialSerializer.write_comment(unsigned short level, Ogre::String const &comment)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::MaterialManager < Ogre::Ogre::ResourceManager

  Proxy of C++ Ogre::MaterialManager class


*/
swig_class SwigClassMaterialManager;


/*
  Document-method: Ogre::MaterialManager.DEFAULT_SCHEME_NAME

  call-seq:
    DEFAULT_SCHEME_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::MaterialManager.DEFAULT_SCHEME_NAME=

  call-seq:
    DEFAULT_SCHEME_NAME=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::MaterialManager.MaterialManager_DEFAULT_SCHEME_NAME

  call-seq:
    MaterialManager_DEFAULT_SCHEME_NAME -> String

Get value of attribute.

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



/*
  Document-method: Ogre::MaterialManager.MaterialManager_DEFAULT_SCHEME_NAME=

  call-seq:
    MaterialManager_DEFAULT_SCHEME_NAME=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::MaterialManager.new

  call-seq:
    MaterialManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::MaterialManager *)new Ogre::MaterialManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MaterialManager(Ogre::MaterialManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::MaterialManager.initialise

  call-seq:
    initialise

An instance method.

*/
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);
  {
    try {
      (arg1)->initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager.parse_script

  call-seq:
    parse_script(DataStreamPtr stream, String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager_parse_script(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;
  }
  {
    try {
      (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager.set_default_texture_filtering

  call-seq:
    set_default_texture_filtering(TextureFilterOptions fo)
    set_default_texture_filtering(FilterType ftype, FilterOptions opts)
    set_default_texture_filtering(FilterOptions minFilter, FilterOptions magFilter, FilterOptions mipFilter)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager_set_default_texture_filtering__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);
  {
    try {
      (arg1)->setDefaultTextureFiltering(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_set_default_texture_filtering__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);
  {
    try {
      (arg1)->setDefaultTextureFiltering(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_set_default_texture_filtering__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);
  {
    try {
      (arg1)->setDefaultTextureFiltering(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialManager_set_default_texture_filtering(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_set_default_texture_filtering__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_set_default_texture_filtering__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_set_default_texture_filtering__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MaterialManager.set_default_texture_filtering", 
    "    void MaterialManager.set_default_texture_filtering(Ogre::TextureFilterOptions fo)\n"
    "    void MaterialManager.set_default_texture_filtering(Ogre::FilterType ftype, Ogre::FilterOptions opts)\n"
    "    void MaterialManager.set_default_texture_filtering(Ogre::FilterOptions minFilter, Ogre::FilterOptions magFilter, Ogre::FilterOptions mipFilter)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager.get_default_texture_filtering

  call-seq:
    get_default_texture_filtering(FilterType ftype) -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager_get_default_texture_filtering(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);
  {
    try {
      result = (Ogre::FilterOptions)((Ogre::MaterialManager const *)arg1)->getDefaultTextureFiltering(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager.set_default_anisotropy

  call-seq:
    set_default_anisotropy(unsigned int maxAniso)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager_set_default_anisotropy(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);
  {
    try {
      (arg1)->setDefaultAnisotropy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager.get_default_anisotropy

  call-seq:
    get_default_anisotropy -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager_get_default_anisotropy(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);
  {
    try {
      result = (unsigned int)((Ogre::MaterialManager const *)arg1)->getDefaultAnisotropy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager.get_default_settings

  call-seq:
    get_default_settings -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager_get_default_settings(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);
  {
    try {
      result = ((Ogre::MaterialManager const *)arg1)->getDefaultSettings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager._get_scheme_index

  call-seq:
    _get_scheme_index(String name) -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager__get_scheme_index(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;
  }
  {
    try {
      result = (unsigned short)(arg1)->_getSchemeIndex((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::MaterialManager._get_scheme_name

  call-seq:
    _get_scheme_name(unsigned short index) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager__get_scheme_name(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);
  {
    try {
      result = (Ogre::String *) &(arg1)->_getSchemeName(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager._get_active_scheme_index

  call-seq:
    _get_active_scheme_index -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager__get_active_scheme_index(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);
  {
    try {
      result = (unsigned short)((Ogre::MaterialManager const *)arg1)->_getActiveSchemeIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager.get_active_scheme

  call-seq:
    get_active_scheme -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager_get_active_scheme(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::MaterialManager const *)arg1)->getActiveScheme();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager.set_active_scheme

  call-seq:
    set_active_scheme(String schemeName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager_set_active_scheme(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;
  }
  {
    try {
      (arg1)->setActiveScheme((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager.add_listener

  call-seq:
    add_listener(Listener l, String schemeName=BLANK)
    add_listener(Listener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager_add_listener__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;
  }
  {
    try {
      (arg1)->addListener(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_add_listener__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);
  {
    try {
      (arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialManager_add_listener(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_add_listener__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_add_listener__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MaterialManager.add_listener", 
    "    void MaterialManager.add_listener(Ogre::MaterialManager::Listener *l, Ogre::String const &schemeName)\n"
    "    void MaterialManager.add_listener(Ogre::MaterialManager::Listener *l)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager.remove_listener

  call-seq:
    remove_listener(Listener l, String schemeName=BLANK)
    remove_listener(Listener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager_remove_listener__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;
  }
  {
    try {
      (arg1)->removeListener(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_remove_listener__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);
  {
    try {
      (arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialManager_remove_listener(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_remove_listener__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_remove_listener__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MaterialManager.remove_listener", 
    "    void MaterialManager.remove_listener(Ogre::MaterialManager::Listener *l, Ogre::String const &schemeName)\n"
    "    void MaterialManager.remove_listener(Ogre::MaterialManager::Listener *l)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager._arbitrate_missing_technique_for_active_scheme

  call-seq:
    _arbitrate_missing_technique_for_active_scheme(Material mat, unsigned short lodIndex, Renderable rend) -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager__arbitrate_missing_technique_for_active_scheme(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);
  {
    try {
      result = (Ogre::Technique *)(arg1)->_arbitrateMissingTechniqueForActiveScheme(arg2,arg3,(Ogre::Renderable const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager.get_singleton

  call-seq:
    get_singleton -> MaterialManager

A class method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::MaterialManager *) &Ogre::MaterialManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> MaterialManager

A class method.

*/
SWIGINTERN VALUE
_wrap_MaterialManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::MaterialManager *)Ogre::MaterialManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::StringConverter

  Proxy of C++ Ogre::StringConverter class


*/
swig_class SwigClassStringConverter;


/*
  Document-method: Ogre::StringConverter.to_string

  call-seq:
    to_string(Real val, unsigned short precision=6, unsigned short width=0, 
    char fill=' ', std::ios::fmtflags flags=std::ios::fmtflags(0)) -> String
    to_string(Real val, unsigned short precision=6, unsigned short width=0, 
    char fill=' ') -> String
    to_string(Real val, unsigned short precision=6, unsigned short width=0) -> String
    to_string(Real val, unsigned short precision=6) -> String
    to_string(Real val) -> String
    to_string(Radian val, unsigned short precision=6, unsigned short width=0, 
    char fill=' ', std::ios::fmtflags flags=std::ios::fmtflags(0)) -> String
    to_string(Radian val, unsigned short precision=6, unsigned short width=0, 
    char fill=' ') -> String
    to_string(Radian val, unsigned short precision=6, unsigned short width=0) -> String
    to_string(Radian val, unsigned short precision=6) -> String
    to_string(Radian val) -> String
    to_string(Degree val, unsigned short precision=6, unsigned short width=0, 
    char fill=' ', std::ios::fmtflags flags=std::ios::fmtflags(0)) -> String
    to_string(Degree val, unsigned short precision=6, unsigned short width=0, 
    char fill=' ') -> String
    to_string(Degree val, unsigned short precision=6, unsigned short width=0) -> String
    to_string(Degree val, unsigned short precision=6) -> String
    to_string(Degree val) -> String
    to_string(int val, unsigned short width=0, char fill=' ', std::ios::fmtflags flags=std::ios::fmtflags(0)) -> String
    to_string(int val, unsigned short width=0, char fill=' ') -> String
    to_string(int val, unsigned short width=0) -> String
    to_string(int val) -> String
    to_string(size_t val, unsigned short width=0, char fill=' ', 
    std::ios::fmtflags flags=std::ios::fmtflags(0)) -> String
    to_string(size_t val, unsigned short width=0, char fill=' ') -> String
    to_string(size_t val, unsigned short width=0) -> String
    to_string(size_t val) -> String
    to_string(unsigned long val, unsigned short width=0, char fill=' ', 
    std::ios::fmtflags flags=std::ios::fmtflags(0)) -> String
    to_string(unsigned long val, unsigned short width=0, char fill=' ') -> String
    to_string(unsigned long val, unsigned short width=0) -> String
    to_string(unsigned long val) -> String
    to_string(long val, unsigned short width=0, char fill=' ', std::ios::fmtflags flags=std::ios::fmtflags(0)) -> String
    to_string(long val, unsigned short width=0, char fill=' ') -> String
    to_string(long val, unsigned short width=0) -> String
    to_string(long val) -> String
    to_string(bool val, bool yesNo=false) -> String
    to_string(bool val) -> String
    to_string(Vector2 val) -> String
    to_string(Vector3 val) -> String
    to_string(Vector4 val) -> String
    to_string(Matrix3 val) -> String
    to_string(Matrix4 val) -> String
    to_string(Quaternion val) -> String
    to_string(ColourValue val) -> String
    to_string(StringVector val) -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_to_string__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));
    }
  }
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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));
    }
  }
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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));
    }
  }
  {
    try {
      result = Ogre::StringConverter::toString(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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));
    }
  }
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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));
    }
  }
  {
    try {
      result = Ogre::StringConverter::toString(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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));
    }
  }
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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));
    }
  }
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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));
    }
  }
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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));
    }
  }
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString((Ogre::Vector2 const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString((Ogre::Vector3 const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString((Ogre::Vector4 const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString((Ogre::Matrix3 const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString((Ogre::Matrix4 const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString((Ogre::Quaternion const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString((Ogre::ColourValue const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_to_string__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);
  {
    try {
      result = Ogre::StringConverter::toString((Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_to_string(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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__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_to_string__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "StringConverter.to_string", 
    "    Ogre::String StringConverter.to_string(Ogre::Real val, unsigned short precision, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Real val, unsigned short precision, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Real val, unsigned short precision, unsigned short width)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Real val, unsigned short precision)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Real val)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Radian val, unsigned short precision, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Radian val, unsigned short precision, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Radian val, unsigned short precision, unsigned short width)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Radian val, unsigned short precision)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Radian val)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Degree val, unsigned short precision, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Degree val, unsigned short precision, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Degree val, unsigned short precision, unsigned short width)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Degree val, unsigned short precision)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Degree val)\n"
    "    Ogre::String StringConverter.to_string(int val, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.to_string(int val, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.to_string(int val, unsigned short width)\n"
    "    Ogre::String StringConverter.to_string(int val)\n"
    "    Ogre::String StringConverter.to_string(size_t val, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.to_string(size_t val, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.to_string(size_t val, unsigned short width)\n"
    "    Ogre::String StringConverter.to_string(size_t val)\n"
    "    Ogre::String StringConverter.to_string(unsigned long val, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.to_string(unsigned long val, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.to_string(unsigned long val, unsigned short width)\n"
    "    Ogre::String StringConverter.to_string(unsigned long val)\n"
    "    Ogre::String StringConverter.to_string(long val, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.to_string(long val, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.to_string(long val, unsigned short width)\n"
    "    Ogre::String StringConverter.to_string(long val)\n"
    "    Ogre::String StringConverter.to_string(bool val, bool yesNo)\n"
    "    Ogre::String StringConverter.to_string(bool val)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Vector2 const &val)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Vector3 const &val)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Vector4 const &val)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Matrix3 const &val)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Matrix4 const &val)\n"
    "    Ogre::String StringConverter.to_string(Ogre::Quaternion const &val)\n"
    "    Ogre::String StringConverter.to_string(Ogre::ColourValue const &val)\n"
    "    Ogre::String StringConverter.to_string(Ogre::StringVector const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_real

  call-seq:
    parse_real(String val, Real defaultValue=0) -> Real
    parse_real(String val) -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_real__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);
  {
    try {
      result = (Ogre::Real)Ogre::StringConverter::parseReal((std::string const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_real__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;
  }
  {
    try {
      result = (Ogre::Real)Ogre::StringConverter::parseReal((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_parse_real(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_parse_real__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_parse_real__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_real", 
    "    Ogre::Real StringConverter.parse_real(Ogre::String const &val, Ogre::Real defaultValue)\n"
    "    Ogre::Real StringConverter.parse_real(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_angle

  call-seq:
    parse_angle(String val, Radian defaultValue=Ogre::Radian(0)) -> Radian
    parse_angle(String val) -> Radian

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_angle__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));
    }
  }
  {
    try {
      result = Ogre::StringConverter::parseAngle((std::string const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_parse_angle__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;
  }
  {
    try {
      result = Ogre::StringConverter::parseAngle((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_angle(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_parse_angle__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_parse_angle__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_angle", 
    "    Ogre::Radian StringConverter.parse_angle(Ogre::String const &val, Ogre::Radian defaultValue)\n"
    "    Ogre::Radian StringConverter.parse_angle(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_int

  call-seq:
    parse_int(String val, int defaultValue=0) -> int
    parse_int(String val) -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_int__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);
  {
    try {
      result = (int)Ogre::StringConverter::parseInt((std::string const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_int__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;
  }
  {
    try {
      result = (int)Ogre::StringConverter::parseInt((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_parse_int(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_parse_int__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_parse_int__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_int", 
    "    int StringConverter.parse_int(Ogre::String const &val, int defaultValue)\n"
    "    int StringConverter.parse_int(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_unsigned_int

  call-seq:
    parse_unsigned_int(String val, unsigned int defaultValue=0) -> unsigned int
    parse_unsigned_int(String val) -> unsigned int

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_unsigned_int__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);
  {
    try {
      result = (unsigned int)Ogre::StringConverter::parseUnsignedInt((std::string const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_unsigned_int__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;
  }
  {
    try {
      result = (unsigned int)Ogre::StringConverter::parseUnsignedInt((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_parse_unsigned_int(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_parse_unsigned_int__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_parse_unsigned_int__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_unsigned_int", 
    "    unsigned int StringConverter.parse_unsigned_int(Ogre::String const &val, unsigned int defaultValue)\n"
    "    unsigned int StringConverter.parse_unsigned_int(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_long

  call-seq:
    parse_long(String val, long defaultValue=0) -> long
    parse_long(String val) -> long

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_long__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);
  {
    try {
      result = (long)Ogre::StringConverter::parseLong((std::string const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_long__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;
  }
  {
    try {
      result = (long)Ogre::StringConverter::parseLong((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_parse_long(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_parse_long__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_parse_long__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_long", 
    "    long StringConverter.parse_long(Ogre::String const &val, long defaultValue)\n"
    "    long StringConverter.parse_long(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_unsigned_long

  call-seq:
    parse_unsigned_long(String val, unsigned long defaultValue=0) -> unsigned long
    parse_unsigned_long(String val) -> unsigned long

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_unsigned_long__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);
  {
    try {
      result = (unsigned long)Ogre::StringConverter::parseUnsignedLong((std::string const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_unsigned_long__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;
  }
  {
    try {
      result = (unsigned long)Ogre::StringConverter::parseUnsignedLong((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_parse_unsigned_long(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_parse_unsigned_long__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_parse_unsigned_long__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_unsigned_long", 
    "    unsigned long StringConverter.parse_unsigned_long(Ogre::String const &val, unsigned long defaultValue)\n"
    "    unsigned long StringConverter.parse_unsigned_long(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_size_t

  call-seq:
    parse_size_t(String val, size_t defaultValue=0) -> size_t
    parse_size_t(String val) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_size_t__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  int res1 = SWIG_OLDOBJ ;
  size_t 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;
  }
  {
    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::parseSizeT", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseSizeT", 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::StringConverter::parseSizeT", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      result = Ogre::StringConverter::parseSizeT((std::string const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_StringConverter_parse_size_t__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = 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;
  }
  {
    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::parseSizeT", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseSizeT", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = Ogre::StringConverter::parseSizeT((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_StringConverter_parse_size_t(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_parse_size_t__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_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_parse_size_t__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_size_t", 
    "    size_t StringConverter.parse_size_t(Ogre::String const &val, size_t defaultValue)\n"
    "    size_t StringConverter.parse_size_t(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_bool

  call-seq:
    parse_bool(String val, bool defaultValue=0) -> bool
    parse_bool(String val) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_bool__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);
  {
    try {
      result = (bool)Ogre::StringConverter::parseBool((std::string const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_bool__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;
  }
  {
    try {
      result = (bool)Ogre::StringConverter::parseBool((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_parse_bool(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_parse_bool__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_parse_bool__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_bool", 
    "    bool StringConverter.parse_bool(Ogre::String const &val, bool defaultValue)\n"
    "    bool StringConverter.parse_bool(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_vector2

  call-seq:
    parse_vector2(String val, Vector2 defaultValue=ZERO) -> Vector2
    parse_vector2(String val) -> Vector2

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_vector2__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);
  {
    try {
      result = Ogre::StringConverter::parseVector2((std::string const &)*arg1,(Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parse_vector2__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;
  }
  {
    try {
      result = Ogre::StringConverter::parseVector2((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_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 == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parse_vector2__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_parse_vector2__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_vector2", 
    "    Ogre::Vector2 StringConverter.parse_vector2(Ogre::String const &val, Ogre::Vector2 const &defaultValue)\n"
    "    Ogre::Vector2 StringConverter.parse_vector2(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_vector3

  call-seq:
    parse_vector3(String val, Vector3 defaultValue=) -> Vector3
    parse_vector3(String val) -> Vector3

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_vector3__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);
  {
    try {
      result = Ogre::StringConverter::parseVector3((std::string const &)*arg1,(Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parse_vector3__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;
  }
  {
    try {
      result = Ogre::StringConverter::parseVector3((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_vector3(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_parse_vector3__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_parse_vector3__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_vector3", 
    "    Ogre::Vector3 StringConverter.parse_vector3(Ogre::String const &val, Ogre::Vector3 const &defaultValue)\n"
    "    Ogre::Vector3 StringConverter.parse_vector3(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_vector4

  call-seq:
    parse_vector4(String val, Vector4 defaultValue=ZERO) -> Vector4
    parse_vector4(String val) -> Vector4

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_vector4__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);
  {
    try {
      result = Ogre::StringConverter::parseVector4((std::string const &)*arg1,(Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_parse_vector4__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;
  }
  {
    try {
      result = Ogre::StringConverter::parseVector4((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_vector4(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_parse_vector4__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_parse_vector4__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_vector4", 
    "    Ogre::Vector4 StringConverter.parse_vector4(Ogre::String const &val, Ogre::Vector4 const &defaultValue)\n"
    "    Ogre::Vector4 StringConverter.parse_vector4(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_matrix3

  call-seq:
    parse_matrix3(String val, Matrix3 defaultValue=IDENTITY) -> Matrix3
    parse_matrix3(String val) -> Matrix3

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_matrix3__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);
  {
    try {
      result = Ogre::StringConverter::parseMatrix3((std::string const &)*arg1,(Ogre::Matrix3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_parse_matrix3__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;
  }
  {
    try {
      result = Ogre::StringConverter::parseMatrix3((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_matrix3(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_parse_matrix3__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_parse_matrix3__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_matrix3", 
    "    Ogre::Matrix3 StringConverter.parse_matrix3(Ogre::String const &val, Ogre::Matrix3 const &defaultValue)\n"
    "    Ogre::Matrix3 StringConverter.parse_matrix3(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_matrix4

  call-seq:
    parse_matrix4(String val, Matrix4 defaultValue=IDENTITY) -> Matrix4
    parse_matrix4(String val) -> Matrix4

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_matrix4__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);
  {
    try {
      result = Ogre::StringConverter::parseMatrix4((std::string const &)*arg1,(Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_parse_matrix4__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;
  }
  {
    try {
      result = Ogre::StringConverter::parseMatrix4((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_matrix4(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_parse_matrix4__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_parse_matrix4__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_matrix4", 
    "    Ogre::Matrix4 StringConverter.parse_matrix4(Ogre::String const &val, Ogre::Matrix4 const &defaultValue)\n"
    "    Ogre::Matrix4 StringConverter.parse_matrix4(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_quaternion

  call-seq:
    parse_quaternion(String val, Quaternion defaultValue=IDENTITY) -> Quaternion
    parse_quaternion(String val) -> Quaternion

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_quaternion__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);
  {
    try {
      result = Ogre::StringConverter::parseQuaternion((std::string const &)*arg1,(Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_parse_quaternion__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;
  }
  {
    try {
      result = Ogre::StringConverter::parseQuaternion((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_quaternion(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parse_quaternion__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_parse_quaternion__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_quaternion", 
    "    Ogre::Quaternion StringConverter.parse_quaternion(Ogre::String const &val, Ogre::Quaternion const &defaultValue)\n"
    "    Ogre::Quaternion StringConverter.parse_quaternion(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_colour_value

  call-seq:
    parse_colour_value(String val, ColourValue defaultValue=Black) -> ColourValue
    parse_colour_value(String val) -> ColourValue

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_colour_value__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);
  {
    try {
      result = Ogre::StringConverter::parseColourValue((std::string const &)*arg1,(Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_parse_colour_value__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;
  }
  {
    try {
      result = Ogre::StringConverter::parseColourValue((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_parse_colour_value(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_parse_colour_value__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_parse_colour_value__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parse_colour_value", 
    "    Ogre::ColourValue StringConverter.parse_colour_value(Ogre::String const &val, Ogre::ColourValue const &defaultValue)\n"
    "    Ogre::ColourValue StringConverter.parse_colour_value(Ogre::String const &val)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StringConverter.parse_string_vector

  call-seq:
    parse_string_vector(String val) -> StringVector

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_parse_string_vector(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;
  }
  {
    try {
      result = Ogre::StringConverter::parseStringVector((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::StringConverter.is_number

  call-seq:
    is_number(String val) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_StringConverter_is_number(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;
  }
  {
    try {
      result = (bool)Ogre::StringConverter::isNumber((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
  }
  


/*
  Document-method: Ogre::StringConverter.new

  call-seq:
    StringConverter.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::StringConverter *)new Ogre::StringConverter();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_StringConverter(Ogre::StringConverter *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::LogListener

  Proxy of C++ Ogre::LogListener class


*/
swig_class SwigClassLogListener;

SWIGINTERN void
free_Ogre_LogListener(Ogre::LogListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::LogListener.message_logged

  call-seq:
    message_logged(String message, LogMessageLevel lml, bool maskDebug, 
    String logName, bool skipThisMessage)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LogListener_message_logged(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);
  {
    try {
      (arg1)->messageLogged((Ogre::String const &)*arg2,arg3,arg4,(Ogre::String const &)*arg5,*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}



/*
  Document-class: Ogre::Log

  Proxy of C++ Ogre::Log class


*/
swig_class SwigClassLog;


/*
  Document-method: Ogre::Log.new

  call-seq:
    Log.new(String name, bool debugOutput=true, bool suppressFileOutput=false)
    Log.new(String name, bool debugOutput=true)
    Log.new(String name)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Log *)new Ogre::Log((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Log *)new Ogre::Log((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Log *)new Ogre::Log((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::Log.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Log_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Log const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Log.is_debug_output_enabled

  call-seq:
    is_debug_output_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Log_is_debug_output_enabled(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);
  {
    try {
      result = (bool)((Ogre::Log const *)arg1)->isDebugOutputEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Log.is_file_output_suppressed

  call-seq:
    is_file_output_suppressed -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Log_is_file_output_suppressed(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);
  {
    try {
      result = (bool)((Ogre::Log const *)arg1)->isFileOutputSuppressed();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Log.is_time_stamp_enabled

  call-seq:
    is_time_stamp_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Log_is_time_stamp_enabled(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);
  {
    try {
      result = (bool)((Ogre::Log const *)arg1)->isTimeStampEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Log.log_message

  call-seq:
    log_message(String message, LogMessageLevel lml=LML_NORMAL, bool maskDebug=false)
    log_message(String message, LogMessageLevel lml=LML_NORMAL)
    log_message(String message)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Log_log_message__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);
  {
    try {
      (arg1)->logMessage((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_log_message__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);
  {
    try {
      (arg1)->logMessage((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_log_message__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;
  }
  {
    try {
      (arg1)->logMessage((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Log_log_message(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_log_message__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_log_message__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_log_message__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Log.log_message", 
    "    void Log.log_message(Ogre::String const &message, Ogre::LogMessageLevel lml, bool maskDebug)\n"
    "    void Log.log_message(Ogre::String const &message, Ogre::LogMessageLevel lml)\n"
    "    void Log.log_message(Ogre::String const &message)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Log.stream

  call-seq:
    stream(LogMessageLevel lml=LML_NORMAL, bool maskDebug=false) -> Stream
    stream(LogMessageLevel lml=LML_NORMAL) -> Stream
    stream -> Stream

An instance method.

*/
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);
  {
    try {
      result = (arg1)->stream(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->stream(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->stream();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Log.set_debug_output_enabled

  call-seq:
    set_debug_output_enabled(bool debugOutput)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Log_set_debug_output_enabled(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);
  {
    try {
      (arg1)->setDebugOutputEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Log.set_log_detail

  call-seq:
    set_log_detail(LoggingLevel ll)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Log_set_log_detail(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);
  {
    try {
      (arg1)->setLogDetail(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Log.set_time_stamp_enabled

  call-seq:
    set_time_stamp_enabled(bool timeStamp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Log_set_time_stamp_enabled(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);
  {
    try {
      (arg1)->setTimeStampEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Log.get_log_detail

  call-seq:
    get_log_detail -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Log_get_log_detail(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);
  {
    try {
      result = (Ogre::LoggingLevel)((Ogre::Log const *)arg1)->getLogDetail();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Log.add_listener

  call-seq:
    add_listener(LogListener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Log_add_listener(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);
  {
    try {
      (arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Log.remove_listener

  call-seq:
    remove_listener(LogListener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Log_remove_listener(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);
  {
    try {
      (arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::LogManager

  Proxy of C++ Ogre::LogManager class


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


/*
  Document-method: Ogre::LogManager.new

  call-seq:
    LogManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::LogManager *)new Ogre::LogManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_LogManager(Ogre::LogManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::LogManager.create_log

  call-seq:
    create_log(String name, bool defaultLog=false, bool debuggerOutput=true, 
    bool suppressFileOutput=false) -> Log
    create_log(String name, bool defaultLog=false, bool debuggerOutput=true) -> Log
    create_log(String name, bool defaultLog=false) -> Log
    create_log(String name) -> Log

An instance method.

*/
SWIGINTERN VALUE
_wrap_LogManager_create_log__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);
  {
    try {
      result = (Ogre::Log *)(arg1)->createLog((Ogre::String const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_log__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);
  {
    try {
      result = (Ogre::Log *)(arg1)->createLog((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_log__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);
  {
    try {
      result = (Ogre::Log *)(arg1)->createLog((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_log__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;
  }
  {
    try {
      result = (Ogre::Log *)(arg1)->createLog((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_log(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_create_log__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_create_log__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_create_log__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_create_log__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "LogManager.create_log", 
    "    Ogre::Log * LogManager.create_log(Ogre::String const &name, bool defaultLog, bool debuggerOutput, bool suppressFileOutput)\n"
    "    Ogre::Log * LogManager.create_log(Ogre::String const &name, bool defaultLog, bool debuggerOutput)\n"
    "    Ogre::Log * LogManager.create_log(Ogre::String const &name, bool defaultLog)\n"
    "    Ogre::Log * LogManager.create_log(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::LogManager.get_log

  call-seq:
    get_log(String name) -> Log

An instance method.

*/
SWIGINTERN VALUE
_wrap_LogManager_get_log(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;
  }
  {
    try {
      result = (Ogre::Log *)(arg1)->getLog((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Log, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::LogManager.get_default_log

  call-seq:
    get_default_log -> Log

An instance method.

*/
SWIGINTERN VALUE
_wrap_LogManager_get_default_log(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);
  {
    try {
      result = (Ogre::Log *)(arg1)->getDefaultLog();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LogManager.destroy_log

  call-seq:
    destroy_log(String name)
    destroy_log(Log log)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LogManager_destroy_log__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;
  }
  {
    try {
      (arg1)->destroyLog((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_destroy_log__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);
  {
    try {
      (arg1)->destroyLog(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_LogManager_destroy_log(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_destroy_log__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_destroy_log__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "LogManager.destroy_log", 
    "    void LogManager.destroy_log(Ogre::String const &name)\n"
    "    void LogManager.destroy_log(Ogre::Log *log)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::LogManager.set_default_log

  call-seq:
    set_default_log(Log newLog) -> Log

An instance method.

*/
SWIGINTERN VALUE
_wrap_LogManager_set_default_log(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);
  {
    try {
      result = (Ogre::Log *)(arg1)->setDefaultLog(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LogManager.log_message

  call-seq:
    log_message(String message, LogMessageLevel lml=LML_NORMAL, bool maskDebug=false)
    log_message(String message, LogMessageLevel lml=LML_NORMAL)
    log_message(String message)
    log_message(LogMessageLevel lml, String message, bool maskDebug=false)
    log_message(LogMessageLevel lml, String message)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LogManager_log_message__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);
  {
    try {
      (arg1)->logMessage((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_log_message__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);
  {
    try {
      (arg1)->logMessage((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_log_message__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;
  }
  {
    try {
      (arg1)->logMessage((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_log_message__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);
  {
    try {
      (arg1)->logMessage(arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_log_message__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;
  }
  {
    try {
      (arg1)->logMessage(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_LogManager_log_message(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_log_message__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_log_message__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_log_message__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_log_message__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_log_message__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "LogManager.log_message", 
    "    void LogManager.log_message(Ogre::String const &message, Ogre::LogMessageLevel lml, bool maskDebug)\n"
    "    void LogManager.log_message(Ogre::String const &message, Ogre::LogMessageLevel lml)\n"
    "    void LogManager.log_message(Ogre::String const &message)\n"
    "    void LogManager.log_message(Ogre::LogMessageLevel lml, Ogre::String const &message, bool maskDebug)\n"
    "    void LogManager.log_message(Ogre::LogMessageLevel lml, Ogre::String const &message)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::LogManager.stream

  call-seq:
    stream(LogMessageLevel lml=LML_NORMAL, bool maskDebug=false) -> Stream
    stream(LogMessageLevel lml=LML_NORMAL) -> Stream
    stream -> Stream

An instance method.

*/
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);
  {
    try {
      result = (arg1)->stream(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->stream(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->stream();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::LogManager.set_log_detail

  call-seq:
    set_log_detail(LoggingLevel ll)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LogManager_set_log_detail(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);
  {
    try {
      (arg1)->setLogDetail(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LogManager.get_singleton

  call-seq:
    get_singleton -> LogManager

A class method.

*/
SWIGINTERN VALUE
_wrap_LogManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::LogManager *) &Ogre::LogManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LogManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LogManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> LogManager

A class method.

*/
SWIGINTERN VALUE
_wrap_LogManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::LogManager *)Ogre::LogManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LogManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DriverVersion

  Proxy of C++ Ogre::DriverVersion class


*/
swig_class SwigClassDriverVersion;


/*
  Document-method: Ogre::DriverVersion.major

  call-seq:
    major -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::DriverVersion.major=

  call-seq:
    major=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::DriverVersion.minor

  call-seq:
    minor -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::DriverVersion.minor=

  call-seq:
    minor=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::DriverVersion.release

  call-seq:
    release -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::DriverVersion.release=

  call-seq:
    release=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::DriverVersion.build

  call-seq:
    build -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::DriverVersion.build=

  call-seq:
    build=(x) -> int

Set new value for attribute.

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


/*
  Document-method: Ogre::DriverVersion.new

  call-seq:
    DriverVersion.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::DriverVersion *)new Ogre::DriverVersion();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DriverVersion.to_string

  call-seq:
    to_string -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_DriverVersion_to_string(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);
  {
    try {
      result = ((Ogre::DriverVersion const *)arg1)->toString();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DriverVersion.from_string

  call-seq:
    from_string(String versionString)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DriverVersion_from_string(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;
  }
  {
    try {
      (arg1)->fromString((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_Ogre_DriverVersion(Ogre::DriverVersion *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::RenderSystemCapabilities

  Proxy of C++ Ogre::RenderSystemCapabilities class


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


/*
  Document-method: Ogre::RenderSystemCapabilities.new

  call-seq:
    RenderSystemCapabilities.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderSystemCapabilities *)new Ogre::RenderSystemCapabilities();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderSystemCapabilities(Ogre::RenderSystemCapabilities *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderSystemCapabilities.calculate_size

  call-seq:
    calculate_size -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_calculate_size(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);
  {
    try {
      result = ((Ogre::RenderSystemCapabilities const *)arg1)->calculateSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_driver_version

  call-seq:
    set_driver_version(DriverVersion version)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_driver_version(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);
  {
    try {
      (arg1)->setDriverVersion((Ogre::DriverVersion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.parse_driver_version_from_string

  call-seq:
    parse_driver_version_from_string(String versionString)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_parse_driver_version_from_string(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;
  }
  {
    try {
      (arg1)->parseDriverVersionFromString((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_driver_version

  call-seq:
    get_driver_version -> DriverVersion

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_driver_version(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);
  {
    try {
      result = ((Ogre::RenderSystemCapabilities const *)arg1)->getDriverVersion();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::DriverVersion(static_cast< const Ogre::DriverVersion& >(result))), SWIGTYPE_p_Ogre__DriverVersion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_vendor

  call-seq:
    get_vendor -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_vendor(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);
  {
    try {
      result = (Ogre::GPUVendor)((Ogre::RenderSystemCapabilities const *)arg1)->getVendor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_vendor

  call-seq:
    set_vendor(GPUVendor v)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_vendor(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);
  {
    try {
      (arg1)->setVendor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.parse_vendor_from_string

  call-seq:
    parse_vendor_from_string(String vendorString)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_parse_vendor_from_string(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;
  }
  {
    try {
      (arg1)->parseVendorFromString((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.vendor_from_string

  call-seq:
    vendor_from_string(String vendorString) -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_vendor_from_string(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;
  }
  {
    try {
      result = (Ogre::GPUVendor)Ogre::RenderSystemCapabilities::vendorFromString((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.vendor_to_string

  call-seq:
    vendor_to_string(GPUVendor v) -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_vendor_to_string(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);
  {
    try {
      result = Ogre::RenderSystemCapabilities::vendorToString(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.is_driver_older_than_version

  call-seq:
    is_driver_older_than_version(DriverVersion v) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_is_driver_older_than_version(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));
    }
  }
  {
    try {
      result = (bool)((Ogre::RenderSystemCapabilities const *)arg1)->isDriverOlderThanVersion(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_num_world_matrices

  call-seq:
    set_num_world_matrices(ushort num)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_num_world_matrices(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);
  {
    try {
      (arg1)->setNumWorldMatrices(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_num_texture_units

  call-seq:
    set_num_texture_units(ushort num)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_num_texture_units(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);
  {
    try {
      (arg1)->setNumTextureUnits(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_stencil_buffer_bit_depth

  call-seq:
    set_stencil_buffer_bit_depth(ushort num)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_stencil_buffer_bit_depth(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);
  {
    try {
      (arg1)->setStencilBufferBitDepth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_num_vertex_blend_matrices

  call-seq:
    set_num_vertex_blend_matrices(ushort num)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_num_vertex_blend_matrices(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);
  {
    try {
      (arg1)->setNumVertexBlendMatrices(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_num_multi_render_targets

  call-seq:
    set_num_multi_render_targets(ushort num)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_num_multi_render_targets(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);
  {
    try {
      (arg1)->setNumMultiRenderTargets(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_num_world_matrices

  call-seq:
    get_num_world_matrices -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_num_world_matrices(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getNumWorldMatrices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_num_texture_units

  call-seq:
    get_num_texture_units -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_num_texture_units(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getNumTextureUnits();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_stencil_buffer_bit_depth

  call-seq:
    get_stencil_buffer_bit_depth -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_stencil_buffer_bit_depth(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getStencilBufferBitDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_num_vertex_blend_matrices

  call-seq:
    get_num_vertex_blend_matrices -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_num_vertex_blend_matrices(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getNumVertexBlendMatrices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_num_multi_render_targets

  call-seq:
    get_num_multi_render_targets -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_num_multi_render_targets(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getNumMultiRenderTargets();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.is_capability_render_system_specific

  call-seq:
    is_capability_render_system_specific(Capabilities c) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_is_capability_render_system_specific(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);
  {
    try {
      result = (bool)((Ogre::RenderSystemCapabilities const *)arg1)->isCapabilityRenderSystemSpecific(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_capability

  call-seq:
    set_capability(Capabilities c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_capability(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);
  {
    try {
      (arg1)->setCapability(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.unset_capability

  call-seq:
    unset_capability(Capabilities c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_unset_capability(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);
  {
    try {
      (arg1)->unsetCapability(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.has_capability

  call-seq:
    has_capability(Capabilities c) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_has_capability(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);
  {
    try {
      result = (bool)((Ogre::RenderSystemCapabilities const *)arg1)->hasCapability(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.add_shader_profile

  call-seq:
    add_shader_profile(String profile)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_add_shader_profile(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;
  }
  {
    try {
      (arg1)->addShaderProfile((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.remove_shader_profile

  call-seq:
    remove_shader_profile(String profile)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_remove_shader_profile(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;
  }
  {
    try {
      (arg1)->removeShaderProfile((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.is_shader_profile_supported

  call-seq:
    is_shader_profile_supported(String profile) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_is_shader_profile_supported(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;
  }
  {
    try {
      result = (bool)((Ogre::RenderSystemCapabilities const *)arg1)->isShaderProfileSupported((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_supported_shader_profiles

  call-seq:
    get_supported_shader_profiles -> ShaderProfiles

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_supported_shader_profiles(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);
  {
    try {
      result = (Ogre::RenderSystemCapabilities::ShaderProfiles *) &((Ogre::RenderSystemCapabilities const *)arg1)->getSupportedShaderProfiles();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__setT_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_vertex_program_constant_float_count

  call-seq:
    get_vertex_program_constant_float_count -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_vertex_program_constant_float_count(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getVertexProgramConstantFloatCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_vertex_program_constant_int_count

  call-seq:
    get_vertex_program_constant_int_count -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_vertex_program_constant_int_count(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getVertexProgramConstantIntCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_vertex_program_constant_bool_count

  call-seq:
    get_vertex_program_constant_bool_count -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_vertex_program_constant_bool_count(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getVertexProgramConstantBoolCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_geometry_program_constant_float_count

  call-seq:
    get_geometry_program_constant_float_count -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_geometry_program_constant_float_count(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getGeometryProgramConstantFloatCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_geometry_program_constant_int_count

  call-seq:
    get_geometry_program_constant_int_count -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_geometry_program_constant_int_count(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getGeometryProgramConstantIntCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_geometry_program_constant_bool_count

  call-seq:
    get_geometry_program_constant_bool_count -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_geometry_program_constant_bool_count(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getGeometryProgramConstantBoolCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_fragment_program_constant_float_count

  call-seq:
    get_fragment_program_constant_float_count -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_fragment_program_constant_float_count(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getFragmentProgramConstantFloatCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_fragment_program_constant_int_count

  call-seq:
    get_fragment_program_constant_int_count -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_fragment_program_constant_int_count(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getFragmentProgramConstantIntCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_fragment_program_constant_bool_count

  call-seq:
    get_fragment_program_constant_bool_count -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_fragment_program_constant_bool_count(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getFragmentProgramConstantBoolCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_device_name

  call-seq:
    set_device_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_device_name(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;
  }
  {
    try {
      (arg1)->setDeviceName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_device_name

  call-seq:
    get_device_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_device_name(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);
  {
    try {
      result = ((Ogre::RenderSystemCapabilities const *)arg1)->getDeviceName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_vertex_program_constant_float_count

  call-seq:
    set_vertex_program_constant_float_count(ushort c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_vertex_program_constant_float_count(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);
  {
    try {
      (arg1)->setVertexProgramConstantFloatCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_vertex_program_constant_int_count

  call-seq:
    set_vertex_program_constant_int_count(ushort c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_vertex_program_constant_int_count(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);
  {
    try {
      (arg1)->setVertexProgramConstantIntCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_vertex_program_constant_bool_count

  call-seq:
    set_vertex_program_constant_bool_count(ushort c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_vertex_program_constant_bool_count(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);
  {
    try {
      (arg1)->setVertexProgramConstantBoolCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_geometry_program_constant_float_count

  call-seq:
    set_geometry_program_constant_float_count(ushort c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_geometry_program_constant_float_count(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);
  {
    try {
      (arg1)->setGeometryProgramConstantFloatCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_geometry_program_constant_int_count

  call-seq:
    set_geometry_program_constant_int_count(ushort c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_geometry_program_constant_int_count(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);
  {
    try {
      (arg1)->setGeometryProgramConstantIntCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_geometry_program_constant_bool_count

  call-seq:
    set_geometry_program_constant_bool_count(ushort c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_geometry_program_constant_bool_count(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);
  {
    try {
      (arg1)->setGeometryProgramConstantBoolCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_fragment_program_constant_float_count

  call-seq:
    set_fragment_program_constant_float_count(ushort c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_fragment_program_constant_float_count(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);
  {
    try {
      (arg1)->setFragmentProgramConstantFloatCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_fragment_program_constant_int_count

  call-seq:
    set_fragment_program_constant_int_count(ushort c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_fragment_program_constant_int_count(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);
  {
    try {
      (arg1)->setFragmentProgramConstantIntCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_fragment_program_constant_bool_count

  call-seq:
    set_fragment_program_constant_bool_count(ushort c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_fragment_program_constant_bool_count(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);
  {
    try {
      (arg1)->setFragmentProgramConstantBoolCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_max_point_size

  call-seq:
    set_max_point_size(Real s)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_max_point_size(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);
  {
    try {
      (arg1)->setMaxPointSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_max_point_size

  call-seq:
    get_max_point_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_max_point_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::RenderSystemCapabilities const *)arg1)->getMaxPointSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_non_pow_2textures_limited

  call-seq:
    set_non_pow_2textures_limited(bool l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_non_pow_2textures_limited(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);
  {
    try {
      (arg1)->setNonPOW2TexturesLimited(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_non_pow_2textures_limited

  call-seq:
    get_non_pow_2textures_limited -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_non_pow_2textures_limited(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);
  {
    try {
      result = (bool)((Ogre::RenderSystemCapabilities const *)arg1)->getNonPOW2TexturesLimited();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_num_vertex_texture_units

  call-seq:
    set_num_vertex_texture_units(ushort n)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_num_vertex_texture_units(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);
  {
    try {
      (arg1)->setNumVertexTextureUnits(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_num_vertex_texture_units

  call-seq:
    get_num_vertex_texture_units -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_num_vertex_texture_units(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getNumVertexTextureUnits();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_vertex_texture_units_shared

  call-seq:
    set_vertex_texture_units_shared(bool shared)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_vertex_texture_units_shared(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);
  {
    try {
      (arg1)->setVertexTextureUnitsShared(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_vertex_texture_units_shared

  call-seq:
    get_vertex_texture_units_shared -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_vertex_texture_units_shared(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);
  {
    try {
      result = (bool)((Ogre::RenderSystemCapabilities const *)arg1)->getVertexTextureUnitsShared();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_geometry_program_num_output_vertices

  call-seq:
    set_geometry_program_num_output_vertices(int numOutputVertices)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_geometry_program_num_output_vertices(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);
  {
    try {
      (arg1)->setGeometryProgramNumOutputVertices(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_geometry_program_num_output_vertices

  call-seq:
    get_geometry_program_num_output_vertices -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_geometry_program_num_output_vertices(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);
  {
    try {
      result = (int)((Ogre::RenderSystemCapabilities const *)arg1)->getGeometryProgramNumOutputVertices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.get_render_system_name

  call-seq:
    get_render_system_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_get_render_system_name(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);
  {
    try {
      result = ((Ogre::RenderSystemCapabilities const *)arg1)->getRenderSystemName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_render_system_name

  call-seq:
    set_render_system_name(String rs)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_render_system_name(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;
  }
  {
    try {
      (arg1)->setRenderSystemName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.set_category_relevant

  call-seq:
    set_category_relevant(CapabilitiesCategory cat, bool relevant)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_set_category_relevant(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);
  {
    try {
      (arg1)->setCategoryRelevant(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.is_category_relevant

  call-seq:
    is_category_relevant(CapabilitiesCategory cat) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_is_category_relevant(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);
  {
    try {
      result = (bool)(arg1)->isCategoryRelevant(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilities.log

  call-seq:
    log(Log pLog)

An instance method.

*/
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);
  {
    try {
      (arg1)->log(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::TextureManager < Ogre::Ogre::ResourceManager

  Proxy of C++ Ogre::TextureManager class


*/
swig_class SwigClassTextureManager;

SWIGINTERN void
free_Ogre_TextureManager(Ogre::TextureManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::TextureManager.create_or_retrieve

  call-seq:
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList createParams=0, 
    TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT, Real gamma=1.0, 
    bool isAlpha=false, PixelFormat desiredFormat=PF_UNKNOWN, 
    bool hwGammaCorrection=false) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList createParams=0, 
    TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT, Real gamma=1.0, 
    bool isAlpha=false, PixelFormat desiredFormat=PF_UNKNOWN) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList createParams=0, 
    TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT, Real gamma=1.0, 
    bool isAlpha=false) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList createParams=0, 
    TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT, Real gamma=1.0) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList createParams=0, 
    TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList createParams=0, 
    TextureType texType=TEX_TYPE_2D) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList createParams=0) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group) -> ResourceCreateOrRetrieveResult

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8,arg9,arg10,arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_create_or_retrieve__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;
  }
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve(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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__SWIG_0(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 13, "TextureManager.create_or_retrieve", 
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.create_or_retrieve(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.create_or_retrieve(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.create_or_retrieve(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.create_or_retrieve(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.create_or_retrieve(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.create_or_retrieve(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.create_or_retrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *createParams)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.create_or_retrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.create_or_retrieve(Ogre::String const &name, Ogre::String const &group, bool isManual)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.create_or_retrieve(Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.prepare

  call-seq:
    prepare(String name, String group, TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT, Real gamma=1.0, 
    bool isAlpha=false, PixelFormat desiredFormat=PF_UNKNOWN, 
    bool hwGammaCorrection=false) -> TexturePtr
    prepare(String name, String group, TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT, Real gamma=1.0, 
    bool isAlpha=false, PixelFormat desiredFormat=PF_UNKNOWN) -> TexturePtr
    prepare(String name, String group, TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT, Real gamma=1.0, 
    bool isAlpha=false) -> TexturePtr
    prepare(String name, String group, TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT, Real gamma=1.0) -> TexturePtr
    prepare(String name, String group, TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT) -> TexturePtr
    prepare(String name, String group, TextureType texType=TEX_TYPE_2D) -> TexturePtr
    prepare(String name, String group) -> TexturePtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
  }
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::TextureManager.load

  call-seq:
    load(String name, String group, TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT, Real gamma=1.0, 
    bool isAlpha=false, PixelFormat desiredFormat=PF_UNKNOWN, 
    bool hwGammaCorrection=false) -> TexturePtr
    load(String name, String group, TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT, Real gamma=1.0, 
    bool isAlpha=false, PixelFormat desiredFormat=PF_UNKNOWN) -> TexturePtr
    load(String name, String group, TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT, Real gamma=1.0, 
    bool isAlpha=false) -> TexturePtr
    load(String name, String group, TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT, Real gamma=1.0) -> TexturePtr
    load(String name, String group, TextureType texType=TEX_TYPE_2D, 
    int numMipmaps=MIP_DEFAULT) -> TexturePtr
    load(String name, String group, TextureType texType=TEX_TYPE_2D) -> TexturePtr
    load(String name, String group) -> TexturePtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
  }
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::TextureManager.load_image

  call-seq:
    load_image(String name, String group, Image img, TextureType texType=TEX_TYPE_2D, 
    int iNumMipmaps=MIP_DEFAULT, 
    Real gamma=1.0, bool isAlpha=false, PixelFormat desiredFormat=PF_UNKNOWN, 
    bool hwGammaCorrection=false) -> TexturePtr
    load_image(String name, String group, Image img, TextureType texType=TEX_TYPE_2D, 
    int iNumMipmaps=MIP_DEFAULT, 
    Real gamma=1.0, bool isAlpha=false, PixelFormat desiredFormat=PF_UNKNOWN) -> TexturePtr
    load_image(String name, String group, Image img, TextureType texType=TEX_TYPE_2D, 
    int iNumMipmaps=MIP_DEFAULT, 
    Real gamma=1.0, bool isAlpha=false) -> TexturePtr
    load_image(String name, String group, Image img, TextureType texType=TEX_TYPE_2D, 
    int iNumMipmaps=MIP_DEFAULT, 
    Real gamma=1.0) -> TexturePtr
    load_image(String name, String group, Image img, TextureType texType=TEX_TYPE_2D, 
    int iNumMipmaps=MIP_DEFAULT) -> TexturePtr
    load_image(String name, String group, Image img, TextureType texType=TEX_TYPE_2D) -> TexturePtr
    load_image(String name, String group, Image img) -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_load_image__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);
  {
    try {
      result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_image__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);
  {
    try {
      result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_image__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);
  {
    try {
      result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_image__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);
  {
    try {
      result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_image__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);
  {
    try {
      result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_image__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);
  {
    try {
      result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_image__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);
  {
    try {
      result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_image(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_load_image__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_load_image__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_load_image__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_load_image__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_load_image__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_load_image__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_load_image__SWIG_0(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 11, "TextureManager.load_image", 
    "    Ogre::TexturePtr TextureManager.load_image(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.load_image(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.load_image(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.load_image(Ogre::String const &name, Ogre::String const &group, Ogre::Image const &img, Ogre::TextureType texType, int iNumMipmaps, Ogre::Real gamma)\n"
    "    Ogre::TexturePtr TextureManager.load_image(Ogre::String const &name, Ogre::String const &group, Ogre::Image const &img, Ogre::TextureType texType, int iNumMipmaps)\n"
    "    Ogre::TexturePtr TextureManager.load_image(Ogre::String const &name, Ogre::String const &group, Ogre::Image const &img, Ogre::TextureType texType)\n"
    "    Ogre::TexturePtr TextureManager.load_image(Ogre::String const &name, Ogre::String const &group, Ogre::Image const &img)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.load_raw_data

  call-seq:
    load_raw_data(String name, String group, DataStreamPtr stream, ushort uWidth, 
    ushort uHeight, PixelFormat format, 
    TextureType texType=TEX_TYPE_2D, int iNumMipmaps=MIP_DEFAULT, 
    Real gamma=1.0, bool hwGammaCorrection=false) -> TexturePtr
    load_raw_data(String name, String group, DataStreamPtr stream, ushort uWidth, 
    ushort uHeight, PixelFormat format, 
    TextureType texType=TEX_TYPE_2D, int iNumMipmaps=MIP_DEFAULT, 
    Real gamma=1.0) -> TexturePtr
    load_raw_data(String name, String group, DataStreamPtr stream, ushort uWidth, 
    ushort uHeight, PixelFormat format, 
    TextureType texType=TEX_TYPE_2D, int iNumMipmaps=MIP_DEFAULT) -> TexturePtr
    load_raw_data(String name, String group, DataStreamPtr stream, ushort uWidth, 
    ushort uHeight, PixelFormat format, 
    TextureType texType=TEX_TYPE_2D) -> TexturePtr
    load_raw_data(String name, String group, DataStreamPtr stream, ushort uWidth, 
    ushort uHeight, PixelFormat format) -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_load_raw_data__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);
  {
    try {
      result = (arg1)->loadRawData((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_raw_data__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);
  {
    try {
      result = (arg1)->loadRawData((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_raw_data__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);
  {
    try {
      result = (arg1)->loadRawData((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_raw_data__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);
  {
    try {
      result = (arg1)->loadRawData((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,*arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_raw_data__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);
  {
    try {
      result = (arg1)->loadRawData((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_raw_data(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_load_raw_data__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_load_raw_data__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_load_raw_data__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_load_raw_data__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_load_raw_data__SWIG_0(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 12, "TextureManager.load_raw_data", 
    "    Ogre::TexturePtr TextureManager.load_raw_data(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.load_raw_data(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.load_raw_data(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.load_raw_data(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.load_raw_data(Ogre::String const &name, Ogre::String const &group, Ogre::DataStreamPtr &stream, Ogre::ushort uWidth, Ogre::ushort uHeight, Ogre::PixelFormat format)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.create_manual

  call-seq:
    create_manual(String name, String group, TextureType texType, uint width, 
    uint height, uint depth, int num_mips, 
    PixelFormat format, int usage=TU_DEFAULT, 
    ManualResourceLoader loader=0, bool hwGammaCorrection=false, 
    uint fsaa=0, String fsaaHint=BLANK) -> TexturePtr
    create_manual(String name, String group, TextureType texType, uint width, 
    uint height, uint depth, int num_mips, 
    PixelFormat format, int usage=TU_DEFAULT, 
    ManualResourceLoader loader=0, bool hwGammaCorrection=false, 
    uint fsaa=0) -> TexturePtr
    create_manual(String name, String group, TextureType texType, uint width, 
    uint height, uint depth, int num_mips, 
    PixelFormat format, int usage=TU_DEFAULT, 
    ManualResourceLoader loader=0, bool hwGammaCorrection=false) -> TexturePtr
    create_manual(String name, String group, TextureType texType, uint width, 
    uint height, uint depth, int num_mips, 
    PixelFormat format, int usage=TU_DEFAULT, 
    ManualResourceLoader loader=0) -> TexturePtr
    create_manual(String name, String group, TextureType texType, uint width, 
    uint height, uint depth, int num_mips, 
    PixelFormat format, int usage=TU_DEFAULT) -> TexturePtr
    create_manual(String name, String group, TextureType texType, uint width, 
    uint height, uint depth, int num_mips, 
    PixelFormat format) -> TexturePtr
    create_manual(String name, String group, TextureType texType, uint width, 
    uint height, int num_mips, PixelFormat format, 
    int usage=TU_DEFAULT, ManualResourceLoader loader=0, 
    bool hwGammaCorrection=false, 
    uint fsaa=0, String fsaaHint=BLANK) -> TexturePtr
    create_manual(String name, String group, TextureType texType, uint width, 
    uint height, int num_mips, PixelFormat format, 
    int usage=TU_DEFAULT, ManualResourceLoader loader=0, 
    bool hwGammaCorrection=false, 
    uint fsaa=0) -> TexturePtr
    create_manual(String name, String group, TextureType texType, uint width, 
    uint height, int num_mips, PixelFormat format, 
    int usage=TU_DEFAULT, ManualResourceLoader loader=0, 
    bool hwGammaCorrection=false) -> TexturePtr
    create_manual(String name, String group, TextureType texType, uint width, 
    uint height, int num_mips, PixelFormat format, 
    int usage=TU_DEFAULT, ManualResourceLoader loader=0) -> TexturePtr
    create_manual(String name, String group, TextureType texType, uint width, 
    uint height, int num_mips, PixelFormat format, 
    int usage=TU_DEFAULT) -> TexturePtr
    create_manual(String name, String group, TextureType texType, uint width, 
    uint height, int num_mips, PixelFormat format) -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_create_manual__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;
  }
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_manual__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);
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_manual__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);
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_manual__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);
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_manual__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);
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_manual__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);
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_manual__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;
  }
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,(Ogre::String const &)*arg13);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_manual__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);
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_manual__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);
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_manual__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);
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_manual__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);
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_manual__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);
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_manual(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_create_manual__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_create_manual__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_create_manual__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_create_manual__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_create_manual__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_create_manual__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_create_manual__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_create_manual__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_create_manual__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_create_manual__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_create_manual__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_create_manual__SWIG_0(nargs, args, self);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 15, "TextureManager.create_manual", 
    "    Ogre::TexturePtr TextureManager.create_manual(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.create_manual(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.create_manual(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.create_manual(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.create_manual(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.create_manual(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.create_manual(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.create_manual(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.create_manual(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.create_manual(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.create_manual(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.create_manual(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;
}



/*
  Document-method: Ogre::TextureManager.set_preferred_integer_bit_depth

  call-seq:
    set_preferred_integer_bit_depth(ushort bits, bool reloadTextures=true)
    set_preferred_integer_bit_depth(ushort bits)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_set_preferred_integer_bit_depth__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);
  {
    try {
      (arg1)->setPreferredIntegerBitDepth(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_set_preferred_integer_bit_depth__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);
  {
    try {
      (arg1)->setPreferredIntegerBitDepth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureManager_set_preferred_integer_bit_depth(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_set_preferred_integer_bit_depth__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_set_preferred_integer_bit_depth__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureManager.set_preferred_integer_bit_depth", 
    "    void TextureManager.set_preferred_integer_bit_depth(Ogre::ushort bits, bool reloadTextures)\n"
    "    void TextureManager.set_preferred_integer_bit_depth(Ogre::ushort bits)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.get_preferred_integer_bit_depth

  call-seq:
    get_preferred_integer_bit_depth -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_get_preferred_integer_bit_depth(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::TextureManager const *)arg1)->getPreferredIntegerBitDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.set_preferred_float_bit_depth

  call-seq:
    set_preferred_float_bit_depth(ushort bits, bool reloadTextures=true)
    set_preferred_float_bit_depth(ushort bits)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_set_preferred_float_bit_depth__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);
  {
    try {
      (arg1)->setPreferredFloatBitDepth(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_set_preferred_float_bit_depth__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);
  {
    try {
      (arg1)->setPreferredFloatBitDepth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureManager_set_preferred_float_bit_depth(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_set_preferred_float_bit_depth__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_set_preferred_float_bit_depth__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureManager.set_preferred_float_bit_depth", 
    "    void TextureManager.set_preferred_float_bit_depth(Ogre::ushort bits, bool reloadTextures)\n"
    "    void TextureManager.set_preferred_float_bit_depth(Ogre::ushort bits)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.get_preferred_float_bit_depth

  call-seq:
    get_preferred_float_bit_depth -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_get_preferred_float_bit_depth(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::TextureManager const *)arg1)->getPreferredFloatBitDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.set_preferred_bit_depths

  call-seq:
    set_preferred_bit_depths(ushort integerBits, ushort floatBits, bool reloadTextures=true)
    set_preferred_bit_depths(ushort integerBits, ushort floatBits)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_set_preferred_bit_depths__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);
  {
    try {
      (arg1)->setPreferredBitDepths(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_set_preferred_bit_depths__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);
  {
    try {
      (arg1)->setPreferredBitDepths(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureManager_set_preferred_bit_depths(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_set_preferred_bit_depths__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_set_preferred_bit_depths__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TextureManager.set_preferred_bit_depths", 
    "    void TextureManager.set_preferred_bit_depths(Ogre::ushort integerBits, Ogre::ushort floatBits, bool reloadTextures)\n"
    "    void TextureManager.set_preferred_bit_depths(Ogre::ushort integerBits, Ogre::ushort floatBits)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.is_format_supported

  call-seq:
    is_format_supported(TextureType ttype, PixelFormat format, int usage) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_is_format_supported(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);
  {
    try {
      result = (bool)(arg1)->isFormatSupported(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.is_equivalent_format_supported

  call-seq:
    is_equivalent_format_supported(TextureType ttype, PixelFormat format, int usage) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_is_equivalent_format_supported(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);
  {
    try {
      result = (bool)(arg1)->isEquivalentFormatSupported(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.get_native_format

  call-seq:
    get_native_format(TextureType ttype, PixelFormat format, int usage) -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_get_native_format(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);
  {
    try {
      result = (Ogre::PixelFormat)(arg1)->getNativeFormat(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.is_hardware_filtering_supported

  call-seq:
    is_hardware_filtering_supported(TextureType ttype, PixelFormat format, int usage, bool preciseFormatOnly=false) -> bool
    is_hardware_filtering_supported(TextureType ttype, PixelFormat format, int usage) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_is_hardware_filtering_supported__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);
  {
    try {
      result = (bool)(arg1)->isHardwareFilteringSupported(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_is_hardware_filtering_supported__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);
  {
    try {
      result = (bool)(arg1)->isHardwareFilteringSupported(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureManager_is_hardware_filtering_supported(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_is_hardware_filtering_supported__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_is_hardware_filtering_supported__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "TextureManager.is_hardware_filtering_supported", 
    "    bool TextureManager.is_hardware_filtering_supported(Ogre::TextureType ttype, Ogre::PixelFormat format, int usage, bool preciseFormatOnly)\n"
    "    bool TextureManager.is_hardware_filtering_supported(Ogre::TextureType ttype, Ogre::PixelFormat format, int usage)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.set_default_num_mipmaps

  call-seq:
    set_default_num_mipmaps(size_t num)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_set_default_num_mipmaps(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);
  {
    try {
      (arg1)->setDefaultNumMipmaps(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.get_default_num_mipmaps

  call-seq:
    get_default_num_mipmaps -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_get_default_num_mipmaps(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);
  {
    try {
      result = (arg1)->getDefaultNumMipmaps();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.get_singleton

  call-seq:
    get_singleton -> TextureManager

A class method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::TextureManager *) &Ogre::TextureManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> TextureManager

A class method.

*/
SWIGINTERN VALUE
_wrap_TextureManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::TextureManager *)Ogre::TextureManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Viewport

  Proxy of C++ Ogre::Viewport class


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


/*
  Document-method: Ogre::Viewport.new

  call-seq:
    Viewport.new(Camera camera, RenderTarget target, Real left, Real top, 
    Real width, Real height, int ZOrder)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Viewport *)new Ogre::Viewport(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Viewport(Ogre::Viewport *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Viewport._update_dimensions

  call-seq:
    _update_dimensions

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport__update_dimensions(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);
  {
    try {
      (arg1)->_updateDimensions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.update

  call-seq:
    update

An instance method.

*/
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);
  {
    try {
      (arg1)->update();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      (arg1)->clear(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->clear(arg2,(Ogre::ColourValue const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->clear(arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->clear(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Viewport.get_target

  call-seq:
    get_target -> RenderTarget

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_target(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);
  {
    try {
      result = (Ogre::RenderTarget *)((Ogre::Viewport const *)arg1)->getTarget();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_camera

  call-seq:
    get_camera -> Camera

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_camera(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);
  {
    try {
      result = (Ogre::Camera *)((Ogre::Viewport const *)arg1)->getCamera();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_camera

  call-seq:
    set_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_camera(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);
  {
    try {
      (arg1)->setCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_zorder

  call-seq:
    get_zorder -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_zorder(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);
  {
    try {
      result = (int)((Ogre::Viewport const *)arg1)->getZOrder();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_left

  call-seq:
    get_left -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_left(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Viewport const *)arg1)->getLeft();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_top

  call-seq:
    get_top -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_top(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Viewport const *)arg1)->getTop();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_width

  call-seq:
    get_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Viewport const *)arg1)->getWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_height

  call-seq:
    get_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Viewport const *)arg1)->getHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_actual_left

  call-seq:
    get_actual_left -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_actual_left(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);
  {
    try {
      result = (int)((Ogre::Viewport const *)arg1)->getActualLeft();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_actual_top

  call-seq:
    get_actual_top -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_actual_top(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);
  {
    try {
      result = (int)((Ogre::Viewport const *)arg1)->getActualTop();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_actual_width

  call-seq:
    get_actual_width -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_actual_width(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);
  {
    try {
      result = (int)((Ogre::Viewport const *)arg1)->getActualWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_actual_height

  call-seq:
    get_actual_height -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_actual_height(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);
  {
    try {
      result = (int)((Ogre::Viewport const *)arg1)->getActualHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_dimensions

  call-seq:
    set_dimensions(Real left, Real top, Real width, Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_dimensions(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);
  {
    try {
      (arg1)->setDimensions(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_orientation_mode

  call-seq:
    set_orientation_mode(OrientationMode orientationMode, bool setDefault=true)
    set_orientation_mode(OrientationMode orientationMode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_orientation_mode__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);
  {
    try {
      (arg1)->setOrientationMode(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_set_orientation_mode__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);
  {
    try {
      (arg1)->setOrientationMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Viewport_set_orientation_mode(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_set_orientation_mode__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_set_orientation_mode__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Viewport.set_orientation_mode", 
    "    void Viewport.set_orientation_mode(Ogre::OrientationMode orientationMode, bool setDefault)\n"
    "    void Viewport.set_orientation_mode(Ogre::OrientationMode orientationMode)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_orientation_mode

  call-seq:
    get_orientation_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_orientation_mode(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);
  {
    try {
      result = (Ogre::OrientationMode)((Ogre::Viewport const *)arg1)->getOrientationMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_default_orientation_mode

  call-seq:
    set_default_orientation_mode(OrientationMode orientationMode)

A class method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_default_orientation_mode(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);
  {
    try {
      Ogre::Viewport::setDefaultOrientationMode(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_default_orientation_mode

  call-seq:
    get_default_orientation_mode -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_default_orientation_mode(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;
  }
  {
    try {
      result = (Ogre::OrientationMode)Ogre::Viewport::getDefaultOrientationMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_background_colour

  call-seq:
    set_background_colour(ColourValue colour)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_background_colour(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);
  {
    try {
      (arg1)->setBackgroundColour((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_background_colour

  call-seq:
    get_background_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_background_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::Viewport const *)arg1)->getBackgroundColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_depth_clear

  call-seq:
    set_depth_clear(Real depth)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_depth_clear(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);
  {
    try {
      (arg1)->setDepthClear(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_depth_clear

  call-seq:
    get_depth_clear -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_depth_clear(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Viewport const *)arg1)->getDepthClear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_clear_every_frame

  call-seq:
    set_clear_every_frame(bool clear, unsigned int buffers=Ogre::FBT_COLOUR|Ogre::FBT_DEPTH)
    set_clear_every_frame(bool clear)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_clear_every_frame__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);
  {
    try {
      (arg1)->setClearEveryFrame(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_set_clear_every_frame__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);
  {
    try {
      (arg1)->setClearEveryFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Viewport_set_clear_every_frame(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_set_clear_every_frame__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_set_clear_every_frame__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Viewport.set_clear_every_frame", 
    "    void Viewport.set_clear_every_frame(bool clear, unsigned int buffers)\n"
    "    void Viewport.set_clear_every_frame(bool clear)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_clear_every_frame

  call-seq:
    get_clear_every_frame -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_clear_every_frame(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);
  {
    try {
      result = (bool)((Ogre::Viewport const *)arg1)->getClearEveryFrame();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_clear_buffers

  call-seq:
    get_clear_buffers -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_clear_buffers(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);
  {
    try {
      result = (unsigned int)((Ogre::Viewport const *)arg1)->getClearBuffers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_auto_updated

  call-seq:
    set_auto_updated(bool autoupdate)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_auto_updated(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);
  {
    try {
      (arg1)->setAutoUpdated(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.is_auto_updated

  call-seq:
    is_auto_updated -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_is_auto_updated(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);
  {
    try {
      result = (bool)((Ogre::Viewport const *)arg1)->isAutoUpdated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_material_scheme

  call-seq:
    set_material_scheme(String schemeName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_material_scheme(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;
  }
  {
    try {
      (arg1)->setMaterialScheme((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_material_scheme

  call-seq:
    get_material_scheme -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_material_scheme(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Viewport const *)arg1)->getMaterialScheme();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_actual_dimensions

  call-seq:
    get_actual_dimensions(int left, int top, int width, int height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_actual_dimensions(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);
  {
    try {
      ((Ogre::Viewport const *)arg1)->getActualDimensions(*arg2,*arg3,*arg4,*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport._is_updated

  call-seq:
    _is_updated -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport__is_updated(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);
  {
    try {
      result = (bool)((Ogre::Viewport const *)arg1)->_isUpdated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport._clear_updated_flag

  call-seq:
    _clear_updated_flag

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport__clear_updated_flag(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);
  {
    try {
      (arg1)->_clearUpdatedFlag();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport._get_num_rendered_faces

  call-seq:
    _get_num_rendered_faces -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport__get_num_rendered_faces(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);
  {
    try {
      result = (unsigned int)((Ogre::Viewport const *)arg1)->_getNumRenderedFaces();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport._get_num_rendered_batches

  call-seq:
    _get_num_rendered_batches -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport__get_num_rendered_batches(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);
  {
    try {
      result = (unsigned int)((Ogre::Viewport const *)arg1)->_getNumRenderedBatches();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_overlays_enabled

  call-seq:
    set_overlays_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_overlays_enabled(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);
  {
    try {
      (arg1)->setOverlaysEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_overlays_enabled

  call-seq:
    get_overlays_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_overlays_enabled(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);
  {
    try {
      result = (bool)((Ogre::Viewport const *)arg1)->getOverlaysEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_skies_enabled

  call-seq:
    set_skies_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_skies_enabled(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);
  {
    try {
      (arg1)->setSkiesEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_skies_enabled

  call-seq:
    get_skies_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_skies_enabled(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);
  {
    try {
      result = (bool)((Ogre::Viewport const *)arg1)->getSkiesEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_shadows_enabled

  call-seq:
    set_shadows_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_shadows_enabled(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);
  {
    try {
      (arg1)->setShadowsEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_shadows_enabled

  call-seq:
    get_shadows_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_shadows_enabled(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);
  {
    try {
      result = (bool)((Ogre::Viewport const *)arg1)->getShadowsEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_visibility_mask

  call-seq:
    set_visibility_mask(uint32 mask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_visibility_mask(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);
  {
    try {
      (arg1)->setVisibilityMask(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_visibility_mask

  call-seq:
    get_visibility_mask -> uint

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_visibility_mask(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);
  {
    try {
      result = (Ogre::uint)((Ogre::Viewport const *)arg1)->getVisibilityMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.set_render_queue_invocation_sequence_name

  call-seq:
    set_render_queue_invocation_sequence_name(String sequenceName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_set_render_queue_invocation_sequence_name(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;
  }
  {
    try {
      (arg1)->setRenderQueueInvocationSequenceName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.get_render_queue_invocation_sequence_name

  call-seq:
    get_render_queue_invocation_sequence_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_get_render_queue_invocation_sequence_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Viewport const *)arg1)->getRenderQueueInvocationSequenceName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport._get_render_queue_invocation_sequence

  call-seq:
    _get_render_queue_invocation_sequence -> RenderQueueInvocationSequence

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport__get_render_queue_invocation_sequence(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);
  {
    try {
      result = (Ogre::RenderQueueInvocationSequence *)(arg1)->_getRenderQueueInvocationSequence();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.point_oriented_to_screen

  call-seq:
    point_oriented_to_screen(Vector2 v, int orientationMode, Vector2 outv)
    point_oriented_to_screen(Real orientedX, Real orientedY, int orientationMode, 
    Real screenX, Real screenY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_point_oriented_to_screen__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);
  {
    try {
      (arg1)->pointOrientedToScreen((Ogre::Vector2 const &)*arg2,arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_point_oriented_to_screen__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);
  {
    try {
      (arg1)->pointOrientedToScreen(arg2,arg3,arg4,*arg5,*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Viewport_point_oriented_to_screen(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_point_oriented_to_screen__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_point_oriented_to_screen__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Viewport.point_oriented_to_screen", 
    "    void Viewport.point_oriented_to_screen(Ogre::Vector2 const &v, int orientationMode, Ogre::Vector2 &outv)\n"
    "    void Viewport.point_oriented_to_screen(Ogre::Real orientedX, Ogre::Real orientedY, int orientationMode, Ogre::Real &screenX, Ogre::Real &screenY)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.add_listener

  call-seq:
    add_listener(Listener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_add_listener(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);
  {
    try {
      (arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.remove_listener

  call-seq:
    remove_listener(Listener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Viewport_remove_listener(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);
  {
    try {
      (arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RenderTarget

  Proxy of C++ Ogre::RenderTarget class


*/
swig_class SwigClassRenderTarget;


/*
  Document-method: Ogre::StatFlags.SF_NONE

  call-seq:
    SF_NONE -> int

A class method.

*/

/*
  Document-method: Ogre::StatFlags.SF_FPS

  call-seq:
    SF_FPS -> int

A class method.

*/

/*
  Document-method: Ogre::StatFlags.SF_AVG_FPS

  call-seq:
    SF_AVG_FPS -> int

A class method.

*/

/*
  Document-method: Ogre::StatFlags.SF_BEST_FPS

  call-seq:
    SF_BEST_FPS -> int

A class method.

*/

/*
  Document-method: Ogre::StatFlags.SF_WORST_FPS

  call-seq:
    SF_WORST_FPS -> int

A class method.

*/

/*
  Document-method: Ogre::StatFlags.SF_TRIANGLE_COUNT

  call-seq:
    SF_TRIANGLE_COUNT -> int

A class method.

*/

/*
  Document-method: Ogre::StatFlags.SF_ALL

  call-seq:
    SF_ALL -> int

A class method.

*/

/*
  Document-method: Ogre::FrameBuffer.FB_FRONT

  call-seq:
    FB_FRONT -> int

A class method.

*/

/*
  Document-method: Ogre::FrameBuffer.FB_BACK

  call-seq:
    FB_BACK -> int

A class method.

*/

/*
  Document-method: Ogre::FrameBuffer.FB_AUTO

  call-seq:
    FB_AUTO -> int

A class method.

*/
SWIGINTERN void
free_Ogre_RenderTarget(Ogre::RenderTarget *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderTarget.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::RenderTarget const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_metrics

  call-seq:
    get_metrics(unsigned int width, unsigned int height, unsigned int colourDepth)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_metrics(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);
  {
    try {
      (arg1)->getMetrics(*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_width

  call-seq:
    get_width -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_width(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);
  {
    try {
      result = (unsigned int)((Ogre::RenderTarget const *)arg1)->getWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_height

  call-seq:
    get_height -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_height(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);
  {
    try {
      result = (unsigned int)((Ogre::RenderTarget const *)arg1)->getHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_colour_depth

  call-seq:
    get_colour_depth -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_colour_depth(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);
  {
    try {
      result = (unsigned int)((Ogre::RenderTarget const *)arg1)->getColourDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.set_depth_buffer_pool

  call-seq:
    set_depth_buffer_pool(uint16 poolId)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_set_depth_buffer_pool(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);
  {
    try {
      (arg1)->setDepthBufferPool(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_depth_buffer_pool

  call-seq:
    get_depth_buffer_pool -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_depth_buffer_pool(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::RenderTarget const *)arg1)->getDepthBufferPool();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_depth_buffer

  call-seq:
    get_depth_buffer -> DepthBuffer

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_depth_buffer(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);
  {
    try {
      result = (Ogre::DepthBuffer *)((Ogre::RenderTarget const *)arg1)->getDepthBuffer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DepthBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.attach_depth_buffer

  call-seq:
    attach_depth_buffer(DepthBuffer depthBuffer) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_attach_depth_buffer(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);
  {
    try {
      result = (bool)(arg1)->attachDepthBuffer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.detach_depth_buffer

  call-seq:
    detach_depth_buffer

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_detach_depth_buffer(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);
  {
    try {
      (arg1)->detachDepthBuffer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget._detach_depth_buffer

  call-seq:
    _detach_depth_buffer

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget__detach_depth_buffer(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);
  {
    try {
      (arg1)->_detachDepthBuffer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.update

  call-seq:
    update(bool swapBuffers=true)
    update

An instance method.

*/
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);
  {
    try {
      (arg1)->update(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->update();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::RenderTarget.swap_buffers

  call-seq:
    swap_buffers(bool waitForVSync=true)
    swap_buffers

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_swap_buffers__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);
  {
    try {
      (arg1)->swapBuffers(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_swap_buffers__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);
  {
    try {
      (arg1)->swapBuffers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget_swap_buffers(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_swap_buffers__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_swap_buffers__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderTarget.swap_buffers", 
    "    void RenderTarget.swap_buffers(bool waitForVSync)\n"
    "    void RenderTarget.swap_buffers()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.add_viewport

  call-seq:
    add_viewport(Camera cam, int ZOrder=0, float left=0.0, float top=0.0, 
    float width=1.0, float height=1.0) -> Viewport
    add_viewport(Camera cam, int ZOrder=0, float left=0.0, float top=0.0, 
    float width=1.0) -> Viewport
    add_viewport(Camera cam, int ZOrder=0, float left=0.0, float top=0.0) -> Viewport
    add_viewport(Camera cam, int ZOrder=0, float left=0.0) -> Viewport
    add_viewport(Camera cam, int ZOrder=0) -> Viewport
    add_viewport(Camera cam) -> Viewport

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_add_viewport__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);
  {
    try {
      result = (Ogre::Viewport *)(arg1)->addViewport(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_add_viewport__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);
  {
    try {
      result = (Ogre::Viewport *)(arg1)->addViewport(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_add_viewport__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);
  {
    try {
      result = (Ogre::Viewport *)(arg1)->addViewport(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_add_viewport__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);
  {
    try {
      result = (Ogre::Viewport *)(arg1)->addViewport(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_add_viewport__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);
  {
    try {
      result = (Ogre::Viewport *)(arg1)->addViewport(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_add_viewport__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);
  {
    try {
      result = (Ogre::Viewport *)(arg1)->addViewport(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget_add_viewport(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_add_viewport__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_add_viewport__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_add_viewport__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_add_viewport__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_add_viewport__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_add_viewport__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "RenderTarget.add_viewport", 
    "    Ogre::Viewport * RenderTarget.add_viewport(Ogre::Camera *cam, int ZOrder, float left, float top, float width, float height)\n"
    "    Ogre::Viewport * RenderTarget.add_viewport(Ogre::Camera *cam, int ZOrder, float left, float top, float width)\n"
    "    Ogre::Viewport * RenderTarget.add_viewport(Ogre::Camera *cam, int ZOrder, float left, float top)\n"
    "    Ogre::Viewport * RenderTarget.add_viewport(Ogre::Camera *cam, int ZOrder, float left)\n"
    "    Ogre::Viewport * RenderTarget.add_viewport(Ogre::Camera *cam, int ZOrder)\n"
    "    Ogre::Viewport * RenderTarget.add_viewport(Ogre::Camera *cam)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_num_viewports

  call-seq:
    get_num_viewports -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_num_viewports(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);
  {
    try {
      result = (unsigned short)((Ogre::RenderTarget const *)arg1)->getNumViewports();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_viewport

  call-seq:
    get_viewport(unsigned short index) -> Viewport

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_viewport(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);
  {
    try {
      result = (Ogre::Viewport *)(arg1)->getViewport(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_viewport_by_zorder

  call-seq:
    get_viewport_by_zorder(int ZOrder) -> Viewport

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_viewport_by_zorder(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);
  {
    try {
      result = (Ogre::Viewport *)(arg1)->getViewportByZOrder(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.has_viewport_with_zorder

  call-seq:
    has_viewport_with_zorder(int ZOrder) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_has_viewport_with_zorder(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);
  {
    try {
      result = (bool)(arg1)->hasViewportWithZOrder(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.remove_viewport

  call-seq:
    remove_viewport(int ZOrder)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_remove_viewport(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);
  {
    try {
      (arg1)->removeViewport(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.remove_all_viewports

  call-seq:
    remove_all_viewports

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_remove_all_viewports(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);
  {
    try {
      (arg1)->removeAllViewports();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_statistics

  call-seq:
    get_statistics(float lastFPS, float avgFPS, float bestFPS, float worstFPS)
    get_statistics -> FrameStats

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_statistics__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);
  {
    try {
      ((Ogre::RenderTarget const *)arg1)->getStatistics(*arg2,*arg3,*arg4,*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_get_statistics__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);
  {
    try {
      result = (Ogre::RenderTarget::FrameStats *) &((Ogre::RenderTarget const *)arg1)->getStatistics();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget__FrameStats, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget_get_statistics(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_get_statistics__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_get_statistics__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "RenderTarget.get_statistics", 
    "    Ogre::RenderTarget::FrameStats const & RenderTarget.get_statistics(float &lastFPS, float &avgFPS, float &bestFPS, float &worstFPS)\n"
    "    Ogre::RenderTarget::FrameStats const & RenderTarget.get_statistics()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_last_fps

  call-seq:
    get_last_fps -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_last_fps(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);
  {
    try {
      result = (float)((Ogre::RenderTarget const *)arg1)->getLastFPS();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_average_fps

  call-seq:
    get_average_fps -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_average_fps(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);
  {
    try {
      result = (float)((Ogre::RenderTarget const *)arg1)->getAverageFPS();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_best_fps

  call-seq:
    get_best_fps -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_best_fps(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);
  {
    try {
      result = (float)((Ogre::RenderTarget const *)arg1)->getBestFPS();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_worst_fps

  call-seq:
    get_worst_fps -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_worst_fps(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);
  {
    try {
      result = (float)((Ogre::RenderTarget const *)arg1)->getWorstFPS();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_best_frame_time

  call-seq:
    get_best_frame_time -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_best_frame_time(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);
  {
    try {
      result = (float)((Ogre::RenderTarget const *)arg1)->getBestFrameTime();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_worst_frame_time

  call-seq:
    get_worst_frame_time -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_worst_frame_time(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);
  {
    try {
      result = (float)((Ogre::RenderTarget const *)arg1)->getWorstFrameTime();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.reset_statistics

  call-seq:
    reset_statistics

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_reset_statistics(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);
  {
    try {
      (arg1)->resetStatistics();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_custom_attribute

  call-seq:
    get_custom_attribute(String name, void pData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_custom_attribute(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] )); 
  }
  {
    try {
      (arg1)->getCustomAttribute((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.add_listener

  call-seq:
    add_listener(RenderTargetListener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_add_listener(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);
  {
    try {
      (arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.remove_listener

  call-seq:
    remove_listener(RenderTargetListener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_remove_listener(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);
  {
    try {
      (arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.remove_all_listeners

  call-seq:
    remove_all_listeners

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_remove_all_listeners(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);
  {
    try {
      (arg1)->removeAllListeners();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.set_priority

  call-seq:
    set_priority(uchar priority)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_set_priority(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);
  {
    try {
      (arg1)->setPriority(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_priority

  call-seq:
    get_priority -> uchar

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_priority(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);
  {
    try {
      result = (Ogre::uchar)((Ogre::RenderTarget const *)arg1)->getPriority();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.is_active

  call-seq:
    is_active -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_is_active(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);
  {
    try {
      result = (bool)((Ogre::RenderTarget const *)arg1)->isActive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.set_active

  call-seq:
    set_active(bool state)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_set_active(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);
  {
    try {
      (arg1)->setActive(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.set_auto_updated

  call-seq:
    set_auto_updated(bool autoupdate)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_set_auto_updated(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);
  {
    try {
      (arg1)->setAutoUpdated(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.is_auto_updated

  call-seq:
    is_auto_updated -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_is_auto_updated(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);
  {
    try {
      result = (bool)((Ogre::RenderTarget const *)arg1)->isAutoUpdated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.copy_contents_to_memory

  call-seq:
    copy_contents_to_memory(PixelBox dst, FrameBuffer buffer=FB_AUTO)
    copy_contents_to_memory(PixelBox dst)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_copy_contents_to_memory__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);
  {
    try {
      (arg1)->copyContentsToMemory((Ogre::PixelBox const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_copy_contents_to_memory__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);
  {
    try {
      (arg1)->copyContentsToMemory((Ogre::PixelBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget_copy_contents_to_memory(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_copy_contents_to_memory__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_copy_contents_to_memory__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RenderTarget.copy_contents_to_memory", 
    "    void RenderTarget.copy_contents_to_memory(Ogre::PixelBox const &dst, Ogre::RenderTarget::FrameBuffer buffer)\n"
    "    void RenderTarget.copy_contents_to_memory(Ogre::PixelBox const &dst)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.suggest_pixel_format

  call-seq:
    suggest_pixel_format -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_suggest_pixel_format(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);
  {
    try {
      result = (Ogre::PixelFormat)((Ogre::RenderTarget const *)arg1)->suggestPixelFormat();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.write_contents_to_file

  call-seq:
    write_contents_to_file(String filename)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_write_contents_to_file(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;
  }
  {
    try {
      (arg1)->writeContentsToFile((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.write_contents_to_timestamped_file

  call-seq:
    write_contents_to_timestamped_file(String filenamePrefix, String filenameSuffix) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_write_contents_to_timestamped_file(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;
  }
  {
    try {
      result = (arg1)->writeContentsToTimestampedFile((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::RenderTarget.requires_texture_flipping

  call-seq:
    requires_texture_flipping -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_requires_texture_flipping(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);
  {
    try {
      result = (bool)((Ogre::RenderTarget const *)arg1)->requiresTextureFlipping();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_triangle_count

  call-seq:
    get_triangle_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_triangle_count(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);
  {
    try {
      result = ((Ogre::RenderTarget const *)arg1)->getTriangleCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_batch_count

  call-seq:
    get_batch_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_batch_count(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);
  {
    try {
      result = ((Ogre::RenderTarget const *)arg1)->getBatchCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget._notify_camera_removed

  call-seq:
    _notify_camera_removed(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget__notify_camera_removed(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);
  {
    try {
      (arg1)->_notifyCameraRemoved((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.is_primary

  call-seq:
    is_primary -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_is_primary(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);
  {
    try {
      result = (bool)((Ogre::RenderTarget const *)arg1)->isPrimary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.is_hardware_gamma_enabled

  call-seq:
    is_hardware_gamma_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_is_hardware_gamma_enabled(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);
  {
    try {
      result = (bool)((Ogre::RenderTarget const *)arg1)->isHardwareGammaEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_fsaa

  call-seq:
    get_fsaa -> uint

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_fsaa(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);
  {
    try {
      result = (Ogre::uint)((Ogre::RenderTarget const *)arg1)->getFSAA();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget.get_fsaahint

  call-seq:
    get_fsaahint -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget_get_fsaahint(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::RenderTarget const *)arg1)->getFSAAHint();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget._get_impl

  call-seq:
    _get_impl -> Impl

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget__get_impl(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);
  {
    try {
      result = (Ogre::RenderTarget::Impl *)(arg1)->_getImpl();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget__Impl, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget._begin_update

  call-seq:
    _begin_update

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget__begin_update(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);
  {
    try {
      (arg1)->_beginUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget._update_viewport

  call-seq:
    _update_viewport(int zorder, bool updateStatistics=true)
    _update_viewport(int zorder)
    _update_viewport(Viewport viewport, bool updateStatistics=true)
    _update_viewport(Viewport viewport)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget__update_viewport__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);
  {
    try {
      (arg1)->_updateViewport(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__update_viewport__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);
  {
    try {
      (arg1)->_updateViewport(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__update_viewport__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);
  {
    try {
      (arg1)->_updateViewport(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__update_viewport__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);
  {
    try {
      (arg1)->_updateViewport(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget__update_viewport(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__update_viewport__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__update_viewport__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__update_viewport__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__update_viewport__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RenderTarget._update_viewport", 
    "    void RenderTarget._update_viewport(int zorder, bool updateStatistics)\n"
    "    void RenderTarget._update_viewport(int zorder)\n"
    "    void RenderTarget._update_viewport(Ogre::Viewport *viewport, bool updateStatistics)\n"
    "    void RenderTarget._update_viewport(Ogre::Viewport *viewport)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget._update_auto_updated_viewports

  call-seq:
    _update_auto_updated_viewports(bool updateStatistics=true)
    _update_auto_updated_viewports

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget__update_auto_updated_viewports__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);
  {
    try {
      (arg1)->_updateAutoUpdatedViewports(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__update_auto_updated_viewports__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);
  {
    try {
      (arg1)->_updateAutoUpdatedViewports();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget__update_auto_updated_viewports(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_auto_updated_viewports__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_auto_updated_viewports__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderTarget._update_auto_updated_viewports", 
    "    void RenderTarget._update_auto_updated_viewports(bool updateStatistics)\n"
    "    void RenderTarget._update_auto_updated_viewports()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderTarget._end_update

  call-seq:
    _end_update

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTarget__end_update(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);
  {
    try {
      (arg1)->_endUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RenderTexture < Ogre::Ogre::RenderTarget

  Proxy of C++ Ogre::RenderTexture class


*/
swig_class SwigClassRenderTexture;

SWIGINTERN void
free_Ogre_RenderTexture(Ogre::RenderTexture *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderTexture.copy_contents_to_memory

  call-seq:
    copy_contents_to_memory(PixelBox dst, FrameBuffer buffer)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTexture_copy_contents_to_memory(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);
  {
    try {
      (arg1)->copyContentsToMemory((Ogre::PixelBox const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTexture.suggest_pixel_format

  call-seq:
    suggest_pixel_format -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTexture_suggest_pixel_format(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);
  {
    try {
      result = (Ogre::PixelFormat)((Ogre::RenderTexture const *)arg1)->suggestPixelFormat();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::MultiRenderTarget < Ogre::Ogre::RenderTarget

  Proxy of C++ Ogre::MultiRenderTarget class


*/
swig_class SwigClassMultiRenderTarget;


/*
  Document-method: Ogre::MultiRenderTarget.bind_surface

  call-seq:
    bind_surface(size_t attachment, RenderTexture target)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MultiRenderTarget_bind_surface(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);
  {
    try {
      (arg1)->bindSurface(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MultiRenderTarget.unbind_surface

  call-seq:
    unbind_surface(size_t attachment)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MultiRenderTarget_unbind_surface(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);
  {
    try {
      (arg1)->unbindSurface(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MultiRenderTarget.copy_contents_to_memory

  call-seq:
    copy_contents_to_memory(PixelBox dst, FrameBuffer buffer)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MultiRenderTarget_copy_contents_to_memory(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);
  {
    try {
      (arg1)->copyContentsToMemory((Ogre::PixelBox const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MultiRenderTarget.suggest_pixel_format

  call-seq:
    suggest_pixel_format -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_MultiRenderTarget_suggest_pixel_format(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);
  {
    try {
      result = (Ogre::PixelFormat)((Ogre::MultiRenderTarget const *)arg1)->suggestPixelFormat();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MultiRenderTarget.get_bound_surface_list

  call-seq:
    get_bound_surface_list -> BoundSufaceList

An instance method.

*/
SWIGINTERN VALUE
_wrap_MultiRenderTarget_get_bound_surface_list(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);
  {
    try {
      result = (Ogre::MultiRenderTarget::BoundSufaceList *) &((Ogre::MultiRenderTarget const *)arg1)->getBoundSurfaceList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__RenderTexture_p_Ogre__STLAllocatorT_Ogre__RenderTexture_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MultiRenderTarget.get_bound_surface

  call-seq:
    get_bound_surface(size_t index) -> RenderTexture

An instance method.

*/
SWIGINTERN VALUE
_wrap_MultiRenderTarget_get_bound_surface(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);
  {
    try {
      result = (Ogre::RenderTexture *)(arg1)->getBoundSurface(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTexture, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MultiRenderTarget(Ogre::MultiRenderTarget *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::FrameEvent

  Proxy of C++ Ogre::FrameEvent class


*/
swig_class SwigClassFrameEvent;


/*
  Document-method: Ogre::FrameEvent.timeSinceLastEvent

  call-seq:
    timeSinceLastEvent -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::FrameEvent.timeSinceLastEvent=

  call-seq:
    timeSinceLastEvent=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::FrameEvent.timeSinceLastFrame

  call-seq:
    timeSinceLastFrame -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::FrameEvent.timeSinceLastFrame=

  call-seq:
    timeSinceLastFrame=(x) -> Real

Set new value for attribute.

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


/*
  Document-method: Ogre::FrameEvent.new

  call-seq:
    FrameEvent.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::FrameEvent *)new Ogre::FrameEvent();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FrameEvent(Ogre::FrameEvent *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::FrameListener

  Proxy of C++ Ogre::FrameListener class


*/
swig_class SwigClassFrameListener;


/*
  Document-method: Ogre::FrameListener.frame_started

  call-seq:
    frame_started(FrameEvent evt) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameListener_frame_started(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 {
    {
      try {
        if (upcall) {
          result = (bool)(arg1)->Ogre::FrameListener::frameStarted((Ogre::FrameEvent const &)*arg2);
        } else {
          result = (bool)(arg1)->frameStarted((Ogre::FrameEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FrameListener.frame_rendering_queued

  call-seq:
    frame_rendering_queued(FrameEvent evt) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameListener_frame_rendering_queued(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 {
    {
      try {
        if (upcall) {
          result = (bool)(arg1)->Ogre::FrameListener::frameRenderingQueued((Ogre::FrameEvent const &)*arg2);
        } else {
          result = (bool)(arg1)->frameRenderingQueued((Ogre::FrameEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FrameListener.frame_ended

  call-seq:
    frame_ended(FrameEvent evt) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameListener_frame_ended(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 {
    {
      try {
        if (upcall) {
          result = (bool)(arg1)->Ogre::FrameListener::frameEnded((Ogre::FrameEvent const &)*arg2);
        } else {
          result = (bool)(arg1)->frameEnded((Ogre::FrameEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } 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;
  }
  


/*
  Document-method: Ogre::FrameListener.new

  call-seq:
    FrameListener.new

Class constructor.

*/
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;
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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;
}



/*
  Document-class: Ogre::ConfigOption

  Proxy of C++ Ogre::ConfigOption class


*/
swig_class SwigClassConfigOption;


/*
  Document-method: Ogre::ConfigOption.name

  call-seq:
    name -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ConfigOption.name=

  call-seq:
    name=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ConfigOption.currentValue

  call-seq:
    currentValue -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ConfigOption.currentValue=

  call-seq:
    currentValue=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ConfigOption.possibleValues

  call-seq:
    possibleValues -> StringVector

Get value of attribute.

*/

/*
  Document-method: Ogre::ConfigOption.possibleValues=

  call-seq:
    possibleValues=(x) -> StringVector

Set new value for attribute.

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



/*
  Document-method: Ogre::ConfigOption.immutable

  call-seq:
    immutable -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::ConfigOption.immutable=

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

Set new value for attribute.

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


/*
  Document-method: Ogre::ConfigOption.new

  call-seq:
    ConfigOption.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ConfigOption *)new Ogre::ConfigOption();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ConfigOption(Ogre::ConfigOption *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::RenderSystem

  Proxy of C++ Ogre::RenderSystem class


*/
swig_class SwigClassRenderSystem;

SWIGINTERN void
free_Ogre_RenderSystem(Ogre::RenderSystem *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderSystem.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::RenderSystem const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_config_options

  call-seq:
    get_config_options -> ConfigOptionMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_config_options(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);
  {
    try {
      result = (Ogre::ConfigOptionMap *) &(arg1)->getConfigOptions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::RenderSystem.set_config_option

  call-seq:
    set_config_option(String name, String value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_config_option(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;
  }
  {
    try {
      (arg1)->setConfigOption((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::RenderSystem.create_hardware_occlusion_query

  call-seq:
    create_hardware_occlusion_query -> HardwareOcclusionQuery

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_create_hardware_occlusion_query(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);
  {
    try {
      result = (Ogre::HardwareOcclusionQuery *)(arg1)->createHardwareOcclusionQuery();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareOcclusionQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.destroy_hardware_occlusion_query

  call-seq:
    destroy_hardware_occlusion_query(HardwareOcclusionQuery hq)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_destroy_hardware_occlusion_query(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);
  {
    try {
      (arg1)->destroyHardwareOcclusionQuery(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.validate_config_options

  call-seq:
    validate_config_options -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_validate_config_options(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);
  {
    try {
      result = (arg1)->validateConfigOptions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._initialise

  call-seq:
    _initialise(bool autoCreateWindow, String windowTitle="OGRE Render Window") -> RenderWindow
    _initialise(bool autoCreateWindow) -> RenderWindow

An instance method.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderWindow *)(arg1)->_initialise(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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);
  {
    try {
      result = (Ogre::RenderWindow *)(arg1)->_initialise(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::RenderSystem.create_render_system_capabilities

  call-seq:
    create_render_system_capabilities -> RenderSystemCapabilities

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_create_render_system_capabilities(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);
  {
    try {
      result = (Ogre::RenderSystemCapabilities *)((Ogre::RenderSystem const *)arg1)->createRenderSystemCapabilities();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_mutable_capabilities

  call-seq:
    get_mutable_capabilities -> RenderSystemCapabilities

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_mutable_capabilities(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);
  {
    try {
      result = (Ogre::RenderSystemCapabilities *)(arg1)->getMutableCapabilities();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.use_custom_render_system_capabilities

  call-seq:
    use_custom_render_system_capabilities(RenderSystemCapabilities capabilities)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_use_custom_render_system_capabilities(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);
  {
    try {
      (arg1)->useCustomRenderSystemCapabilities(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.reinitialise

  call-seq:
    reinitialise

An instance method.

*/
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);
  {
    try {
      (arg1)->reinitialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.shutdown

  call-seq:
    shutdown

An instance method.

*/
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);
  {
    try {
      (arg1)->shutdown();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_ambient_light

  call-seq:
    set_ambient_light(float r, float g, float b)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_ambient_light(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);
  {
    try {
      (arg1)->setAmbientLight(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_shading_type

  call-seq:
    set_shading_type(ShadeOptions so)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_shading_type(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);
  {
    try {
      (arg1)->setShadingType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_lighting_enabled

  call-seq:
    set_lighting_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_lighting_enabled(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);
  {
    try {
      (arg1)->setLightingEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_wbuffer_enabled

  call-seq:
    set_wbuffer_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_wbuffer_enabled(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);
  {
    try {
      (arg1)->setWBufferEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_wbuffer_enabled

  call-seq:
    get_wbuffer_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_wbuffer_enabled(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);
  {
    try {
      result = (bool)((Ogre::RenderSystem const *)arg1)->getWBufferEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._create_render_window

  call-seq:
    _create_render_window(String name, unsigned int width, unsigned int height, 
    bool fullScreen, NameValuePairList miscParams=0) -> RenderWindow
    _create_render_window(String name, unsigned int width, unsigned int height, 
    bool fullScreen) -> RenderWindow

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__create_render_window__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);
  {
    try {
      result = (Ogre::RenderWindow *)(arg1)->_createRenderWindow((Ogre::String const &)*arg2,arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__create_render_window__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);
  {
    try {
      result = (Ogre::RenderWindow *)(arg1)->_createRenderWindow((Ogre::String const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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__create_render_window(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__create_render_window__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__create_render_window__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "RenderSystem._create_render_window", 
    "    Ogre::RenderWindow * RenderSystem._create_render_window(Ogre::String const &name, unsigned int width, unsigned int height, bool fullScreen, Ogre::NameValuePairList const *miscParams)\n"
    "    Ogre::RenderWindow * RenderSystem._create_render_window(Ogre::String const &name, unsigned int width, unsigned int height, bool fullScreen)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._create_render_windows

  call-seq:
    _create_render_windows(RenderWindowDescriptionList renderWindowDescriptions, 
    RenderWindowList createdWindows) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__create_render_windows(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);
  {
    try {
      result = (bool)(arg1)->_createRenderWindows((Ogre::RenderWindowDescriptionList const &)*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.create_multi_render_target

  call-seq:
    create_multi_render_target(String name) -> MultiRenderTarget

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_create_multi_render_target(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;
  }
  {
    try {
      result = (Ogre::MultiRenderTarget *)(arg1)->createMultiRenderTarget((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MultiRenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.destroy_render_window

  call-seq:
    destroy_render_window(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_destroy_render_window(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;
  }
  {
    try {
      (arg1)->destroyRenderWindow((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.destroy_render_texture

  call-seq:
    destroy_render_texture(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_destroy_render_texture(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;
  }
  {
    try {
      (arg1)->destroyRenderTexture((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.destroy_render_target

  call-seq:
    destroy_render_target(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_destroy_render_target(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;
  }
  {
    try {
      (arg1)->destroyRenderTarget((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.attach_render_target

  call-seq:
    attach_render_target(RenderTarget target)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_attach_render_target(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);
  {
    try {
      (arg1)->attachRenderTarget(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_render_target

  call-seq:
    get_render_target(String name) -> RenderTarget

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_render_target(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;
  }
  {
    try {
      result = (Ogre::RenderTarget *)(arg1)->getRenderTarget((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.detach_render_target

  call-seq:
    detach_render_target(String name) -> RenderTarget

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_detach_render_target(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;
  }
  {
    try {
      result = (Ogre::RenderTarget *)(arg1)->detachRenderTarget((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_render_target_iterator

  call-seq:
    get_render_target_iterator -> RenderTargetIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_render_target_iterator(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);
  {
    try {
      result = (arg1)->getRenderTargetIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::RenderSystem.get_error_description

  call-seq:
    get_error_description(long errorNumber) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_error_description(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);
  {
    try {
      result = ((Ogre::RenderSystem const *)arg1)->getErrorDescription(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_wait_for_vertical_blank

  call-seq:
    set_wait_for_vertical_blank(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_wait_for_vertical_blank(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);
  {
    try {
      (arg1)->setWaitForVerticalBlank(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_wait_for_vertical_blank

  call-seq:
    get_wait_for_vertical_blank -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_wait_for_vertical_blank(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);
  {
    try {
      result = (bool)((Ogre::RenderSystem const *)arg1)->getWaitForVerticalBlank();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_global_instance_vertex_buffer

  call-seq:
    get_global_instance_vertex_buffer -> HardwareVertexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_global_instance_vertex_buffer(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);
  {
    try {
      result = ((Ogre::RenderSystem const *)arg1)->getGlobalInstanceVertexBuffer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::HardwareVertexBufferSharedPtr(static_cast< const Ogre::HardwareVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_global_instance_vertex_buffer

  call-seq:
    set_global_instance_vertex_buffer(HardwareVertexBufferSharedPtr val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_global_instance_vertex_buffer(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));
    }
  }
  {
    try {
      (arg1)->setGlobalInstanceVertexBuffer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_global_instance_vertex_buffer_vertex_declaration

  call-seq:
    get_global_instance_vertex_buffer_vertex_declaration -> VertexDeclaration

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_global_instance_vertex_buffer_vertex_declaration(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);
  {
    try {
      result = (Ogre::VertexDeclaration *)((Ogre::RenderSystem const *)arg1)->getGlobalInstanceVertexBufferVertexDeclaration();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_global_instance_vertex_buffer_vertex_declaration

  call-seq:
    set_global_instance_vertex_buffer_vertex_declaration(VertexDeclaration val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_global_instance_vertex_buffer_vertex_declaration(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);
  {
    try {
      (arg1)->setGlobalInstanceVertexBufferVertexDeclaration(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_global_number_of_instances

  call-seq:
    get_global_number_of_instances -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_global_number_of_instances(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);
  {
    try {
      result = ((Ogre::RenderSystem const *)arg1)->getGlobalNumberOfInstances();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_global_number_of_instances

  call-seq:
    set_global_number_of_instances(size_t val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_global_number_of_instances(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);
  {
    try {
      (arg1)->setGlobalNumberOfInstances(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_fixed_pipeline_enabled

  call-seq:
    set_fixed_pipeline_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_fixed_pipeline_enabled(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);
  {
    try {
      (arg1)->setFixedPipelineEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_fixed_pipeline_enabled

  call-seq:
    get_fixed_pipeline_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_fixed_pipeline_enabled(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);
  {
    try {
      result = (bool)((Ogre::RenderSystem const *)arg1)->getFixedPipelineEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_depth_buffer_for

  call-seq:
    set_depth_buffer_for(RenderTarget renderTarget)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_depth_buffer_for(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);
  {
    try {
      (arg1)->setDepthBufferFor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._use_lights

  call-seq:
    _use_lights(LightList lights, unsigned short limit)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__use_lights(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);
  {
    try {
      (arg1)->_useLights((Ogre::LightList const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.are_fixed_function_lights_in_view_space

  call-seq:
    are_fixed_function_lights_in_view_space -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_are_fixed_function_lights_in_view_space(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);
  {
    try {
      result = (bool)((Ogre::RenderSystem const *)arg1)->areFixedFunctionLightsInViewSpace();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_world_matrix

  call-seq:
    _set_world_matrix(Matrix4 m)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_world_matrix(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);
  {
    try {
      (arg1)->_setWorldMatrix((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_world_matrices

  call-seq:
    _set_world_matrices(Matrix4 m, unsigned short count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_world_matrices(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);
  {
    try {
      (arg1)->_setWorldMatrices((Ogre::Matrix4 const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_view_matrix

  call-seq:
    _set_view_matrix(Matrix4 m)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_view_matrix(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);
  {
    try {
      (arg1)->_setViewMatrix((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_projection_matrix

  call-seq:
    _set_projection_matrix(Matrix4 m)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_projection_matrix(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);
  {
    try {
      (arg1)->_setProjectionMatrix((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_texture_unit_settings

  call-seq:
    _set_texture_unit_settings(size_t texUnit, TextureUnitState tl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_unit_settings(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);
  {
    try {
      (arg1)->_setTextureUnitSettings(arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._disable_texture_unit

  call-seq:
    _disable_texture_unit(size_t texUnit)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__disable_texture_unit(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);
  {
    try {
      (arg1)->_disableTextureUnit(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._disable_texture_units_from

  call-seq:
    _disable_texture_units_from(size_t texUnit)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__disable_texture_units_from(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);
  {
    try {
      (arg1)->_disableTextureUnitsFrom(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_surface_params

  call-seq:
    _set_surface_params(ColourValue ambient, ColourValue diffuse, ColourValue specular, 
    ColourValue emissive, Real shininess, 
    TrackVertexColourType tracking=TVC_NONE)
    _set_surface_params(ColourValue ambient, ColourValue diffuse, ColourValue specular, 
    ColourValue emissive, Real shininess)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_surface_params__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);
  {
    try {
      (arg1)->_setSurfaceParams((Ogre::ColourValue const &)*arg2,(Ogre::ColourValue const &)*arg3,(Ogre::ColourValue const &)*arg4,(Ogre::ColourValue const &)*arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_surface_params__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);
  {
    try {
      (arg1)->_setSurfaceParams((Ogre::ColourValue const &)*arg2,(Ogre::ColourValue const &)*arg3,(Ogre::ColourValue const &)*arg4,(Ogre::ColourValue const &)*arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__set_surface_params(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__set_surface_params__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__set_surface_params__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "RenderSystem._set_surface_params", 
    "    void RenderSystem._set_surface_params(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._set_surface_params(Ogre::ColourValue const &ambient, Ogre::ColourValue const &diffuse, Ogre::ColourValue const &specular, Ogre::ColourValue const &emissive, Ogre::Real shininess)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_point_sprites_enabled

  call-seq:
    _set_point_sprites_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_point_sprites_enabled(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);
  {
    try {
      (arg1)->_setPointSpritesEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_point_parameters

  call-seq:
    _set_point_parameters(Real size, bool attenuationEnabled, Real constant, 
    Real linear, Real quadratic, Real minSize, Real maxSize)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_point_parameters(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);
  {
    try {
      (arg1)->_setPointParameters(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_texture

  call-seq:
    _set_texture(size_t unit, bool enabled, TexturePtr texPtr)
    _set_texture(size_t unit, bool enabled, String texname)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_texture__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);
  {
    try {
      (arg1)->_setTexture(arg2,arg3,(Ogre::TexturePtr const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_texture__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;
  }
  {
    try {
      (arg1)->_setTexture(arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__set_texture(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__set_texture__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__set_texture__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderSystem._set_texture", 
    "    void RenderSystem._set_texture(size_t unit, bool enabled, Ogre::TexturePtr const &texPtr)\n"
    "    void RenderSystem._set_texture(size_t unit, bool enabled, Ogre::String const &texname)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_vertex_texture

  call-seq:
    _set_vertex_texture(size_t unit, TexturePtr tex)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_vertex_texture(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);
  {
    try {
      (arg1)->_setVertexTexture(arg2,(Ogre::TexturePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_texture_coord_set

  call-seq:
    _set_texture_coord_set(size_t unit, size_t index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_coord_set(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);
  {
    try {
      (arg1)->_setTextureCoordSet(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_texture_coord_calculation

  call-seq:
    _set_texture_coord_calculation(size_t unit, TexCoordCalcMethod m, Frustum frustum=0)
    _set_texture_coord_calculation(size_t unit, TexCoordCalcMethod m)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_coord_calculation__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);
  {
    try {
      (arg1)->_setTextureCoordCalculation(arg2,arg3,(Ogre::Frustum const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_coord_calculation__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);
  {
    try {
      (arg1)->_setTextureCoordCalculation(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__set_texture_coord_calculation(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__set_texture_coord_calculation__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__set_texture_coord_calculation__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderSystem._set_texture_coord_calculation", 
    "    void RenderSystem._set_texture_coord_calculation(size_t unit, Ogre::TexCoordCalcMethod m, Ogre::Frustum const *frustum)\n"
    "    void RenderSystem._set_texture_coord_calculation(size_t unit, Ogre::TexCoordCalcMethod m)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_texture_blend_mode

  call-seq:
    _set_texture_blend_mode(size_t unit, LayerBlendModeEx bm)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_blend_mode(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);
  {
    try {
      (arg1)->_setTextureBlendMode(arg2,(Ogre::LayerBlendModeEx const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_texture_unit_filtering

  call-seq:
    _set_texture_unit_filtering(size_t unit, FilterOptions minFilter, FilterOptions magFilter, 
    FilterOptions mipFilter)
    _set_texture_unit_filtering(size_t unit, FilterType ftype, FilterOptions filter)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_unit_filtering__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);
  {
    try {
      (arg1)->_setTextureUnitFiltering(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_unit_filtering__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);
  {
    try {
      (arg1)->_setTextureUnitFiltering(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__set_texture_unit_filtering(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__set_texture_unit_filtering__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__set_texture_unit_filtering__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "RenderSystem._set_texture_unit_filtering", 
    "    void RenderSystem._set_texture_unit_filtering(size_t unit, Ogre::FilterOptions minFilter, Ogre::FilterOptions magFilter, Ogre::FilterOptions mipFilter)\n"
    "    void RenderSystem._set_texture_unit_filtering(size_t unit, Ogre::FilterType ftype, Ogre::FilterOptions filter)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_texture_layer_anisotropy

  call-seq:
    _set_texture_layer_anisotropy(size_t unit, unsigned int maxAnisotropy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_layer_anisotropy(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);
  {
    try {
      (arg1)->_setTextureLayerAnisotropy(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_texture_addressing_mode

  call-seq:
    _set_texture_addressing_mode(size_t unit, UVWAddressingMode uvw)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_addressing_mode(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);
  {
    try {
      (arg1)->_setTextureAddressingMode(arg2,(Ogre::TextureUnitState::UVWAddressingMode const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_texture_border_colour

  call-seq:
    _set_texture_border_colour(size_t unit, ColourValue colour)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_border_colour(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);
  {
    try {
      (arg1)->_setTextureBorderColour(arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_texture_mipmap_bias

  call-seq:
    _set_texture_mipmap_bias(size_t unit, float bias)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_mipmap_bias(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);
  {
    try {
      (arg1)->_setTextureMipmapBias(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_texture_matrix

  call-seq:
    _set_texture_matrix(size_t unit, Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_matrix(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);
  {
    try {
      (arg1)->_setTextureMatrix(arg2,(Ogre::Matrix4 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_scene_blending

  call-seq:
    _set_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, 
    SceneBlendOperation op=SBO_ADD)
    _set_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_scene_blending__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);
  {
    try {
      (arg1)->_setSceneBlending(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_scene_blending__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);
  {
    try {
      (arg1)->_setSceneBlending(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__set_scene_blending(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__set_scene_blending__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__set_scene_blending__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderSystem._set_scene_blending", 
    "    void RenderSystem._set_scene_blending(Ogre::SceneBlendFactor sourceFactor, Ogre::SceneBlendFactor destFactor, Ogre::SceneBlendOperation op)\n"
    "    void RenderSystem._set_scene_blending(Ogre::SceneBlendFactor sourceFactor, Ogre::SceneBlendFactor destFactor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_separate_scene_blending

  call-seq:
    _set_separate_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, 
    SceneBlendFactor sourceFactorAlpha, 
    SceneBlendFactor destFactorAlpha, SceneBlendOperation op=SBO_ADD, 
    SceneBlendOperation alphaOp=SBO_ADD)
    _set_separate_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, 
    SceneBlendFactor sourceFactorAlpha, 
    SceneBlendFactor destFactorAlpha, SceneBlendOperation op=SBO_ADD)
    _set_separate_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, 
    SceneBlendFactor sourceFactorAlpha, 
    SceneBlendFactor destFactorAlpha)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_separate_scene_blending__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);
  {
    try {
      (arg1)->_setSeparateSceneBlending(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_separate_scene_blending__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);
  {
    try {
      (arg1)->_setSeparateSceneBlending(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_separate_scene_blending__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);
  {
    try {
      (arg1)->_setSeparateSceneBlending(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__set_separate_scene_blending(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__set_separate_scene_blending__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__set_separate_scene_blending__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__set_separate_scene_blending__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "RenderSystem._set_separate_scene_blending", 
    "    void RenderSystem._set_separate_scene_blending(Ogre::SceneBlendFactor sourceFactor, Ogre::SceneBlendFactor destFactor, Ogre::SceneBlendFactor sourceFactorAlpha, Ogre::SceneBlendFactor destFactorAlpha, Ogre::SceneBlendOperation op, Ogre::SceneBlendOperation alphaOp)\n"
    "    void RenderSystem._set_separate_scene_blending(Ogre::SceneBlendFactor sourceFactor, Ogre::SceneBlendFactor destFactor, Ogre::SceneBlendFactor sourceFactorAlpha, Ogre::SceneBlendFactor destFactorAlpha, Ogre::SceneBlendOperation op)\n"
    "    void RenderSystem._set_separate_scene_blending(Ogre::SceneBlendFactor sourceFactor, Ogre::SceneBlendFactor destFactor, Ogre::SceneBlendFactor sourceFactorAlpha, Ogre::SceneBlendFactor destFactorAlpha)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_alpha_reject_settings

  call-seq:
    _set_alpha_reject_settings(CompareFunction func, unsigned char value, bool alphaToCoverage)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_alpha_reject_settings(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);
  {
    try {
      (arg1)->_setAlphaRejectSettings(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_texture_projection_relative_to

  call-seq:
    _set_texture_projection_relative_to(bool enabled, Vector3 pos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_texture_projection_relative_to(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);
  {
    try {
      (arg1)->_setTextureProjectionRelativeTo(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._create_depth_buffer_for

  call-seq:
    _create_depth_buffer_for(RenderTarget renderTarget) -> DepthBuffer

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__create_depth_buffer_for(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);
  {
    try {
      result = (Ogre::DepthBuffer *)(arg1)->_createDepthBufferFor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DepthBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._cleanup_depth_buffers

  call-seq:
    _cleanup_depth_buffers(bool bCleanManualBuffers=true)
    _cleanup_depth_buffers

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__cleanup_depth_buffers__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);
  {
    try {
      (arg1)->_cleanupDepthBuffers(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__cleanup_depth_buffers__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);
  {
    try {
      (arg1)->_cleanupDepthBuffers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__cleanup_depth_buffers(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__cleanup_depth_buffers__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__cleanup_depth_buffers__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderSystem._cleanup_depth_buffers", 
    "    void RenderSystem._cleanup_depth_buffers(bool bCleanManualBuffers)\n"
    "    void RenderSystem._cleanup_depth_buffers()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._begin_frame

  call-seq:
    _begin_frame

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__begin_frame(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);
  {
    try {
      (arg1)->_beginFrame();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._pause_frame

  call-seq:
    _pause_frame -> RenderSystemContext

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__pause_frame(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);
  {
    try {
      result = (Ogre::RenderSystem::RenderSystemContext *)(arg1)->_pauseFrame();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystem__RenderSystemContext, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._resume_frame

  call-seq:
    _resume_frame(RenderSystemContext context)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__resume_frame(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);
  {
    try {
      (arg1)->_resumeFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._end_frame

  call-seq:
    _end_frame

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__end_frame(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);
  {
    try {
      (arg1)->_endFrame();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_viewport

  call-seq:
    _set_viewport(Viewport vp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_viewport(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);
  {
    try {
      (arg1)->_setViewport(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._get_viewport

  call-seq:
    _get_viewport -> Viewport

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__get_viewport(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);
  {
    try {
      result = (Ogre::Viewport *)(arg1)->_getViewport();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_culling_mode

  call-seq:
    _set_culling_mode(CullingMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_culling_mode(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);
  {
    try {
      (arg1)->_setCullingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._get_culling_mode

  call-seq:
    _get_culling_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__get_culling_mode(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);
  {
    try {
      result = (Ogre::CullingMode)((Ogre::RenderSystem const *)arg1)->_getCullingMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_depth_buffer_params

  call-seq:
    _set_depth_buffer_params(bool depthTest=true, bool depthWrite=true, CompareFunction depthFunction=CMPF_LESS_EQUAL)
    _set_depth_buffer_params(bool depthTest=true, bool depthWrite=true)
    _set_depth_buffer_params(bool depthTest=true)
    _set_depth_buffer_params

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_depth_buffer_params__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);
  {
    try {
      (arg1)->_setDepthBufferParams(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_depth_buffer_params__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);
  {
    try {
      (arg1)->_setDepthBufferParams(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_depth_buffer_params__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);
  {
    try {
      (arg1)->_setDepthBufferParams(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_depth_buffer_params__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);
  {
    try {
      (arg1)->_setDepthBufferParams();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__set_depth_buffer_params(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__set_depth_buffer_params__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__set_depth_buffer_params__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__set_depth_buffer_params__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__set_depth_buffer_params__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderSystem._set_depth_buffer_params", 
    "    void RenderSystem._set_depth_buffer_params(bool depthTest, bool depthWrite, Ogre::CompareFunction depthFunction)\n"
    "    void RenderSystem._set_depth_buffer_params(bool depthTest, bool depthWrite)\n"
    "    void RenderSystem._set_depth_buffer_params(bool depthTest)\n"
    "    void RenderSystem._set_depth_buffer_params()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_depth_buffer_check_enabled

  call-seq:
    _set_depth_buffer_check_enabled(bool enabled=true)
    _set_depth_buffer_check_enabled

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_depth_buffer_check_enabled__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);
  {
    try {
      (arg1)->_setDepthBufferCheckEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_depth_buffer_check_enabled__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);
  {
    try {
      (arg1)->_setDepthBufferCheckEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__set_depth_buffer_check_enabled(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__set_depth_buffer_check_enabled__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__set_depth_buffer_check_enabled__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderSystem._set_depth_buffer_check_enabled", 
    "    void RenderSystem._set_depth_buffer_check_enabled(bool enabled)\n"
    "    void RenderSystem._set_depth_buffer_check_enabled()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_depth_buffer_write_enabled

  call-seq:
    _set_depth_buffer_write_enabled(bool enabled=true)
    _set_depth_buffer_write_enabled

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_depth_buffer_write_enabled__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);
  {
    try {
      (arg1)->_setDepthBufferWriteEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_depth_buffer_write_enabled__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);
  {
    try {
      (arg1)->_setDepthBufferWriteEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__set_depth_buffer_write_enabled(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__set_depth_buffer_write_enabled__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__set_depth_buffer_write_enabled__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderSystem._set_depth_buffer_write_enabled", 
    "    void RenderSystem._set_depth_buffer_write_enabled(bool enabled)\n"
    "    void RenderSystem._set_depth_buffer_write_enabled()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_depth_buffer_function

  call-seq:
    _set_depth_buffer_function(CompareFunction func=CMPF_LESS_EQUAL)
    _set_depth_buffer_function

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_depth_buffer_function__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);
  {
    try {
      (arg1)->_setDepthBufferFunction(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_depth_buffer_function__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);
  {
    try {
      (arg1)->_setDepthBufferFunction();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__set_depth_buffer_function(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__set_depth_buffer_function__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__set_depth_buffer_function__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderSystem._set_depth_buffer_function", 
    "    void RenderSystem._set_depth_buffer_function(Ogre::CompareFunction func)\n"
    "    void RenderSystem._set_depth_buffer_function()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_colour_buffer_write_enabled

  call-seq:
    _set_colour_buffer_write_enabled(bool red, bool green, bool blue, bool alpha)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_colour_buffer_write_enabled(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);
  {
    try {
      (arg1)->_setColourBufferWriteEnabled(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_depth_bias

  call-seq:
    _set_depth_bias(float constantBias, float slopeScaleBias=0.0)
    _set_depth_bias(float constantBias)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_depth_bias__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);
  {
    try {
      (arg1)->_setDepthBias(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_depth_bias__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);
  {
    try {
      (arg1)->_setDepthBias(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__set_depth_bias(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__set_depth_bias__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__set_depth_bias__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RenderSystem._set_depth_bias", 
    "    void RenderSystem._set_depth_bias(float constantBias, float slopeScaleBias)\n"
    "    void RenderSystem._set_depth_bias(float constantBias)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_fog

  call-seq:
    _set_fog(FogMode mode=FOG_NONE, ColourValue colour=White, Real expDensity=1.0, 
    Real linearStart=0.0, Real linearEnd=1.0)
    _set_fog(FogMode mode=FOG_NONE, ColourValue colour=White, Real expDensity=1.0, 
    Real linearStart=0.0)
    _set_fog(FogMode mode=FOG_NONE, ColourValue colour=White, Real expDensity=1.0)
    _set_fog(FogMode mode=FOG_NONE, ColourValue colour=White)
    _set_fog(FogMode mode=FOG_NONE)
    _set_fog

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_fog__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);
  {
    try {
      (arg1)->_setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_fog__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);
  {
    try {
      (arg1)->_setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_fog__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);
  {
    try {
      (arg1)->_setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_fog__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);
  {
    try {
      (arg1)->_setFog(arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_fog__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);
  {
    try {
      (arg1)->_setFog(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__set_fog__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);
  {
    try {
      (arg1)->_setFog();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__set_fog(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__set_fog__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__set_fog__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__set_fog__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__set_fog__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__set_fog__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__set_fog__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "RenderSystem._set_fog", 
    "    void RenderSystem._set_fog(Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart, Ogre::Real linearEnd)\n"
    "    void RenderSystem._set_fog(Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart)\n"
    "    void RenderSystem._set_fog(Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity)\n"
    "    void RenderSystem._set_fog(Ogre::FogMode mode, Ogre::ColourValue const &colour)\n"
    "    void RenderSystem._set_fog(Ogre::FogMode mode)\n"
    "    void RenderSystem._set_fog()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._begin_geometry_count

  call-seq:
    _begin_geometry_count

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__begin_geometry_count(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);
  {
    try {
      (arg1)->_beginGeometryCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._get_face_count

  call-seq:
    _get_face_count -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__get_face_count(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);
  {
    try {
      result = (unsigned int)((Ogre::RenderSystem const *)arg1)->_getFaceCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._get_batch_count

  call-seq:
    _get_batch_count -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__get_batch_count(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);
  {
    try {
      result = (unsigned int)((Ogre::RenderSystem const *)arg1)->_getBatchCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._get_vertex_count

  call-seq:
    _get_vertex_count -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__get_vertex_count(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);
  {
    try {
      result = (unsigned int)((Ogre::RenderSystem const *)arg1)->_getVertexCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.convert_colour_value

  call-seq:
    convert_colour_value(ColourValue colour, uint32 pDest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_convert_colour_value(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);
  {
    try {
      (arg1)->convertColourValue((Ogre::ColourValue const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_colour_vertex_element_type

  call-seq:
    get_colour_vertex_element_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_colour_vertex_element_type(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);
  {
    try {
      result = (Ogre::VertexElementType)((Ogre::RenderSystem const *)arg1)->getColourVertexElementType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._convert_projection_matrix

  call-seq:
    _convert_projection_matrix(Matrix4 matrix, Matrix4 dest, bool forGpuProgram=false)
    _convert_projection_matrix(Matrix4 matrix, Matrix4 dest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__convert_projection_matrix__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);
  {
    try {
      (arg1)->_convertProjectionMatrix((Ogre::Matrix4 const &)*arg2,*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__convert_projection_matrix__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);
  {
    try {
      (arg1)->_convertProjectionMatrix((Ogre::Matrix4 const &)*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__convert_projection_matrix(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__convert_projection_matrix__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__convert_projection_matrix__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderSystem._convert_projection_matrix", 
    "    void RenderSystem._convert_projection_matrix(Ogre::Matrix4 const &matrix, Ogre::Matrix4 &dest, bool forGpuProgram)\n"
    "    void RenderSystem._convert_projection_matrix(Ogre::Matrix4 const &matrix, Ogre::Matrix4 &dest)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._make_projection_matrix

  call-seq:
    _make_projection_matrix(Radian fovy, Real aspect, Real nearPlane, Real farPlane, 
    Matrix4 dest, bool forGpuProgram=false)
    _make_projection_matrix(Radian fovy, Real aspect, Real nearPlane, Real farPlane, 
    Matrix4 dest)
    _make_projection_matrix(Real left, Real right, Real bottom, Real top, Real nearPlane, 
    Real farPlane, Matrix4 dest, bool forGpuProgram=false)
    _make_projection_matrix(Real left, Real right, Real bottom, Real top, Real nearPlane, 
    Real farPlane, Matrix4 dest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__make_projection_matrix__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);
  {
    try {
      (arg1)->_makeProjectionMatrix((Ogre::Radian const &)*arg2,arg3,arg4,arg5,*arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__make_projection_matrix__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);
  {
    try {
      (arg1)->_makeProjectionMatrix((Ogre::Radian const &)*arg2,arg3,arg4,arg5,*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__make_projection_matrix__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);
  {
    try {
      (arg1)->_makeProjectionMatrix(arg2,arg3,arg4,arg5,arg6,arg7,*arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__make_projection_matrix__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);
  {
    try {
      (arg1)->_makeProjectionMatrix(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__make_projection_matrix(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__make_projection_matrix__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__make_projection_matrix__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__make_projection_matrix__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__make_projection_matrix__SWIG_2(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 10, "RenderSystem._make_projection_matrix", 
    "    void RenderSystem._make_projection_matrix(Ogre::Radian const &fovy, Ogre::Real aspect, Ogre::Real nearPlane, Ogre::Real farPlane, Ogre::Matrix4 &dest, bool forGpuProgram)\n"
    "    void RenderSystem._make_projection_matrix(Ogre::Radian const &fovy, Ogre::Real aspect, Ogre::Real nearPlane, Ogre::Real farPlane, Ogre::Matrix4 &dest)\n"
    "    void RenderSystem._make_projection_matrix(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._make_projection_matrix(Ogre::Real left, Ogre::Real right, Ogre::Real bottom, Ogre::Real top, Ogre::Real nearPlane, Ogre::Real farPlane, Ogre::Matrix4 &dest)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._make_ortho_matrix

  call-seq:
    _make_ortho_matrix(Radian fovy, Real aspect, Real nearPlane, Real farPlane, 
    Matrix4 dest, bool forGpuProgram=false)
    _make_ortho_matrix(Radian fovy, Real aspect, Real nearPlane, Real farPlane, 
    Matrix4 dest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__make_ortho_matrix__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);
  {
    try {
      (arg1)->_makeOrthoMatrix((Ogre::Radian const &)*arg2,arg3,arg4,arg5,*arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__make_ortho_matrix__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);
  {
    try {
      (arg1)->_makeOrthoMatrix((Ogre::Radian const &)*arg2,arg3,arg4,arg5,*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__make_ortho_matrix(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__make_ortho_matrix__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__make_ortho_matrix__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "RenderSystem._make_ortho_matrix", 
    "    void RenderSystem._make_ortho_matrix(Ogre::Radian const &fovy, Ogre::Real aspect, Ogre::Real nearPlane, Ogre::Real farPlane, Ogre::Matrix4 &dest, bool forGpuProgram)\n"
    "    void RenderSystem._make_ortho_matrix(Ogre::Radian const &fovy, Ogre::Real aspect, Ogre::Real nearPlane, Ogre::Real farPlane, Ogre::Matrix4 &dest)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._apply_oblique_depth_projection

  call-seq:
    _apply_oblique_depth_projection(Matrix4 matrix, Plane plane, bool forGpuProgram)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__apply_oblique_depth_projection(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);
  {
    try {
      (arg1)->_applyObliqueDepthProjection(*arg2,(Ogre::Plane const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_polygon_mode

  call-seq:
    _set_polygon_mode(PolygonMode level)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_polygon_mode(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);
  {
    try {
      (arg1)->_setPolygonMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_stencil_check_enabled

  call-seq:
    set_stencil_check_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_stencil_check_enabled(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);
  {
    try {
      (arg1)->setStencilCheckEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_stencil_buffer_params

  call-seq:
    set_stencil_buffer_params(CompareFunction func=CMPF_ALWAYS_PASS, uint32 refValue=0, 
    uint32 mask=0xFFFFFFFF, StencilOperation stencilFailOp=SOP_KEEP, 
    StencilOperation depthFailOp=SOP_KEEP, 
    StencilOperation passOp=SOP_KEEP, 
    bool twoSidedOperation=false)
    set_stencil_buffer_params(CompareFunction func=CMPF_ALWAYS_PASS, uint32 refValue=0, 
    uint32 mask=0xFFFFFFFF, StencilOperation stencilFailOp=SOP_KEEP, 
    StencilOperation depthFailOp=SOP_KEEP, 
    StencilOperation passOp=SOP_KEEP)
    set_stencil_buffer_params(CompareFunction func=CMPF_ALWAYS_PASS, uint32 refValue=0, 
    uint32 mask=0xFFFFFFFF, StencilOperation stencilFailOp=SOP_KEEP, 
    StencilOperation depthFailOp=SOP_KEEP)
    set_stencil_buffer_params(CompareFunction func=CMPF_ALWAYS_PASS, uint32 refValue=0, 
    uint32 mask=0xFFFFFFFF, StencilOperation stencilFailOp=SOP_KEEP)
    set_stencil_buffer_params(CompareFunction func=CMPF_ALWAYS_PASS, uint32 refValue=0, 
    uint32 mask=0xFFFFFFFF)
    set_stencil_buffer_params(CompareFunction func=CMPF_ALWAYS_PASS, uint32 refValue=0)
    set_stencil_buffer_params(CompareFunction func=CMPF_ALWAYS_PASS)
    set_stencil_buffer_params

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_stencil_buffer_params__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);
  {
    try {
      (arg1)->setStencilBufferParams(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_stencil_buffer_params__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);
  {
    try {
      (arg1)->setStencilBufferParams(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_stencil_buffer_params__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);
  {
    try {
      (arg1)->setStencilBufferParams(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_stencil_buffer_params__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);
  {
    try {
      (arg1)->setStencilBufferParams(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_stencil_buffer_params__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);
  {
    try {
      (arg1)->setStencilBufferParams(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_stencil_buffer_params__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);
  {
    try {
      (arg1)->setStencilBufferParams(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_stencil_buffer_params__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);
  {
    try {
      (arg1)->setStencilBufferParams(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_stencil_buffer_params__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);
  {
    try {
      (arg1)->setStencilBufferParams();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem_set_stencil_buffer_params(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_set_stencil_buffer_params__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_set_stencil_buffer_params__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_set_stencil_buffer_params__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_set_stencil_buffer_params__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_set_stencil_buffer_params__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_set_stencil_buffer_params__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_set_stencil_buffer_params__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_set_stencil_buffer_params__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "RenderSystem.set_stencil_buffer_params", 
    "    void RenderSystem.set_stencil_buffer_params(Ogre::CompareFunction func, Ogre::uint32 refValue, Ogre::uint32 mask, Ogre::StencilOperation stencilFailOp, Ogre::StencilOperation depthFailOp, Ogre::StencilOperation passOp, bool twoSidedOperation)\n"
    "    void RenderSystem.set_stencil_buffer_params(Ogre::CompareFunction func, Ogre::uint32 refValue, Ogre::uint32 mask, Ogre::StencilOperation stencilFailOp, Ogre::StencilOperation depthFailOp, Ogre::StencilOperation passOp)\n"
    "    void RenderSystem.set_stencil_buffer_params(Ogre::CompareFunction func, Ogre::uint32 refValue, Ogre::uint32 mask, Ogre::StencilOperation stencilFailOp, Ogre::StencilOperation depthFailOp)\n"
    "    void RenderSystem.set_stencil_buffer_params(Ogre::CompareFunction func, Ogre::uint32 refValue, Ogre::uint32 mask, Ogre::StencilOperation stencilFailOp)\n"
    "    void RenderSystem.set_stencil_buffer_params(Ogre::CompareFunction func, Ogre::uint32 refValue, Ogre::uint32 mask)\n"
    "    void RenderSystem.set_stencil_buffer_params(Ogre::CompareFunction func, Ogre::uint32 refValue)\n"
    "    void RenderSystem.set_stencil_buffer_params(Ogre::CompareFunction func)\n"
    "    void RenderSystem.set_stencil_buffer_params()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_vertex_declaration

  call-seq:
    set_vertex_declaration(VertexDeclaration decl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_vertex_declaration(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);
  {
    try {
      (arg1)->setVertexDeclaration(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_vertex_buffer_binding

  call-seq:
    set_vertex_buffer_binding(VertexBufferBinding binding)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_vertex_buffer_binding(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);
  {
    try {
      (arg1)->setVertexBufferBinding(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_normalise_normals

  call-seq:
    set_normalise_normals(bool normalise)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_normalise_normals(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);
  {
    try {
      (arg1)->setNormaliseNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._render

  call-seq:
    _render(RenderOperation op)

An instance method.

*/
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);
  {
    try {
      (arg1)->_render((Ogre::RenderOperation const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_capabilities

  call-seq:
    get_capabilities -> RenderSystemCapabilities

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_capabilities(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);
  {
    try {
      result = (Ogre::RenderSystemCapabilities *)((Ogre::RenderSystem const *)arg1)->getCapabilities();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_driver_version

  call-seq:
    get_driver_version -> DriverVersion

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_driver_version(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);
  {
    try {
      result = (Ogre::DriverVersion *) &((Ogre::RenderSystem const *)arg1)->getDriverVersion();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DriverVersion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._get_default_viewport_material_scheme

  call-seq:
    _get_default_viewport_material_scheme -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__get_default_viewport_material_scheme(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::RenderSystem const *)arg1)->_getDefaultViewportMaterialScheme();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.bind_gpu_program

  call-seq:
    bind_gpu_program(GpuProgram prg)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_bind_gpu_program(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);
  {
    try {
      (arg1)->bindGpuProgram(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.bind_gpu_program_parameters

  call-seq:
    bind_gpu_program_parameters(GpuProgramType gptype, GpuProgramParametersSharedPtr params, 
    uint16 variabilityMask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_bind_gpu_program_parameters(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);
  {
    try {
      (arg1)->bindGpuProgramParameters(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.bind_gpu_program_pass_iteration_parameters

  call-seq:
    bind_gpu_program_pass_iteration_parameters(GpuProgramType gptype)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_bind_gpu_program_pass_iteration_parameters(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);
  {
    try {
      (arg1)->bindGpuProgramPassIterationParameters(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.unbind_gpu_program

  call-seq:
    unbind_gpu_program(GpuProgramType gptype)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_unbind_gpu_program(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);
  {
    try {
      (arg1)->unbindGpuProgram(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.is_gpu_program_bound

  call-seq:
    is_gpu_program_bound(GpuProgramType gptype) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_is_gpu_program_bound(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);
  {
    try {
      result = (bool)(arg1)->isGpuProgramBound(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_clip_planes

  call-seq:
    set_clip_planes(PlaneList clipPlanes)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_clip_planes(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);
  {
    try {
      (arg1)->setClipPlanes((Ogre::PlaneList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.add_clip_plane

  call-seq:
    add_clip_plane(Plane p)
    add_clip_plane(Real A, Real B, Real C, Real D)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_add_clip_plane__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);
  {
    try {
      (arg1)->addClipPlane((Ogre::Plane const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_add_clip_plane__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);
  {
    try {
      (arg1)->addClipPlane(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem_add_clip_plane(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_add_clip_plane__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_add_clip_plane__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "RenderSystem.add_clip_plane", 
    "    void RenderSystem.add_clip_plane(Ogre::Plane const &p)\n"
    "    void RenderSystem.add_clip_plane(Ogre::Real A, Ogre::Real B, Ogre::Real C, Ogre::Real D)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.reset_clip_planes

  call-seq:
    reset_clip_planes

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_reset_clip_planes(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);
  {
    try {
      (arg1)->resetClipPlanes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._init_render_targets

  call-seq:
    _init_render_targets

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__init_render_targets(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);
  {
    try {
      (arg1)->_initRenderTargets();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._notify_camera_removed

  call-seq:
    _notify_camera_removed(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__notify_camera_removed(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);
  {
    try {
      (arg1)->_notifyCameraRemoved((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._update_all_render_targets

  call-seq:
    _update_all_render_targets(bool swapBuffers=true)
    _update_all_render_targets

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__update_all_render_targets__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);
  {
    try {
      (arg1)->_updateAllRenderTargets(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__update_all_render_targets__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);
  {
    try {
      (arg1)->_updateAllRenderTargets();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__update_all_render_targets(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__update_all_render_targets__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__update_all_render_targets__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderSystem._update_all_render_targets", 
    "    void RenderSystem._update_all_render_targets(bool swapBuffers)\n"
    "    void RenderSystem._update_all_render_targets()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._swap_all_render_target_buffers

  call-seq:
    _swap_all_render_target_buffers(bool waitForVsync=true)
    _swap_all_render_target_buffers

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__swap_all_render_target_buffers__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);
  {
    try {
      (arg1)->_swapAllRenderTargetBuffers(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__swap_all_render_target_buffers__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);
  {
    try {
      (arg1)->_swapAllRenderTargetBuffers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__swap_all_render_target_buffers(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__swap_all_render_target_buffers__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__swap_all_render_target_buffers__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderSystem._swap_all_render_target_buffers", 
    "    void RenderSystem._swap_all_render_target_buffers(bool waitForVsync)\n"
    "    void RenderSystem._swap_all_render_target_buffers()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_invert_vertex_winding

  call-seq:
    set_invert_vertex_winding(bool invert)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_invert_vertex_winding(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);
  {
    try {
      (arg1)->setInvertVertexWinding(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_invert_vertex_winding

  call-seq:
    get_invert_vertex_winding -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_invert_vertex_winding(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);
  {
    try {
      result = (bool)((Ogre::RenderSystem const *)arg1)->getInvertVertexWinding();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_scissor_test

  call-seq:
    set_scissor_test(bool enabled, size_t left=0, size_t top=0, size_t right=800, 
    size_t bottom=600)
    set_scissor_test(bool enabled, size_t left=0, size_t top=0, size_t right=800)
    set_scissor_test(bool enabled, size_t left=0, size_t top=0)
    set_scissor_test(bool enabled, size_t left=0)
    set_scissor_test(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_scissor_test__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);
  {
    try {
      (arg1)->setScissorTest(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_scissor_test__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);
  {
    try {
      (arg1)->setScissorTest(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_scissor_test__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);
  {
    try {
      (arg1)->setScissorTest(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_scissor_test__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);
  {
    try {
      (arg1)->setScissorTest(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_scissor_test__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);
  {
    try {
      (arg1)->setScissorTest(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem_set_scissor_test(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_set_scissor_test__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_set_scissor_test__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_set_scissor_test__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_set_scissor_test__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_set_scissor_test__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "RenderSystem.set_scissor_test", 
    "    void RenderSystem.set_scissor_test(bool enabled, size_t left, size_t top, size_t right, size_t bottom)\n"
    "    void RenderSystem.set_scissor_test(bool enabled, size_t left, size_t top, size_t right)\n"
    "    void RenderSystem.set_scissor_test(bool enabled, size_t left, size_t top)\n"
    "    void RenderSystem.set_scissor_test(bool enabled, size_t left)\n"
    "    void RenderSystem.set_scissor_test(bool enabled)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.clear_frame_buffer

  call-seq:
    clear_frame_buffer(unsigned int buffers, ColourValue colour=Black, Real depth=1.0, 
    unsigned short stencil=0)
    clear_frame_buffer(unsigned int buffers, ColourValue colour=Black, Real depth=1.0)
    clear_frame_buffer(unsigned int buffers, ColourValue colour=Black)
    clear_frame_buffer(unsigned int buffers)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_clear_frame_buffer__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);
  {
    try {
      (arg1)->clearFrameBuffer(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_clear_frame_buffer__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);
  {
    try {
      (arg1)->clearFrameBuffer(arg2,(Ogre::ColourValue const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_clear_frame_buffer__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);
  {
    try {
      (arg1)->clearFrameBuffer(arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_clear_frame_buffer__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);
  {
    try {
      (arg1)->clearFrameBuffer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem_clear_frame_buffer(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_clear_frame_buffer__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_clear_frame_buffer__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_clear_frame_buffer__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_clear_frame_buffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "RenderSystem.clear_frame_buffer", 
    "    void RenderSystem.clear_frame_buffer(unsigned int buffers, Ogre::ColourValue const &colour, Ogre::Real depth, unsigned short stencil)\n"
    "    void RenderSystem.clear_frame_buffer(unsigned int buffers, Ogre::ColourValue const &colour, Ogre::Real depth)\n"
    "    void RenderSystem.clear_frame_buffer(unsigned int buffers, Ogre::ColourValue const &colour)\n"
    "    void RenderSystem.clear_frame_buffer(unsigned int buffers)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_horizontal_texel_offset

  call-seq:
    get_horizontal_texel_offset -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_horizontal_texel_offset(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getHorizontalTexelOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_vertical_texel_offset

  call-seq:
    get_vertical_texel_offset -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_vertical_texel_offset(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getVerticalTexelOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_minimum_depth_input_value

  call-seq:
    get_minimum_depth_input_value -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_minimum_depth_input_value(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getMinimumDepthInputValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_maximum_depth_input_value

  call-seq:
    get_maximum_depth_input_value -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_maximum_depth_input_value(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getMaximumDepthInputValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_current_pass_iteration_count

  call-seq:
    set_current_pass_iteration_count(size_t count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_current_pass_iteration_count(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);
  {
    try {
      (arg1)->setCurrentPassIterationCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.set_derive_depth_bias

  call-seq:
    set_derive_depth_bias(bool derive, float baseValue=0.0, float multiplier=0.0, 
    float slopeScale=0.0)
    set_derive_depth_bias(bool derive, float baseValue=0.0, float multiplier=0.0)
    set_derive_depth_bias(bool derive, float baseValue=0.0)
    set_derive_depth_bias(bool derive)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_set_derive_depth_bias__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);
  {
    try {
      (arg1)->setDeriveDepthBias(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_derive_depth_bias__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);
  {
    try {
      (arg1)->setDeriveDepthBias(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_derive_depth_bias__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);
  {
    try {
      (arg1)->setDeriveDepthBias(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_set_derive_depth_bias__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);
  {
    try {
      (arg1)->setDeriveDepthBias(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem_set_derive_depth_bias(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_set_derive_depth_bias__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_set_derive_depth_bias__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_set_derive_depth_bias__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_set_derive_depth_bias__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "RenderSystem.set_derive_depth_bias", 
    "    void RenderSystem.set_derive_depth_bias(bool derive, float baseValue, float multiplier, float slopeScale)\n"
    "    void RenderSystem.set_derive_depth_bias(bool derive, float baseValue, float multiplier)\n"
    "    void RenderSystem.set_derive_depth_bias(bool derive, float baseValue)\n"
    "    void RenderSystem.set_derive_depth_bias(bool derive)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem._set_render_target

  call-seq:
    _set_render_target(RenderTarget target)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem__set_render_target(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);
  {
    try {
      (arg1)->_setRenderTarget(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.add_listener

  call-seq:
    add_listener(Listener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_add_listener(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);
  {
    try {
      (arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.remove_listener

  call-seq:
    remove_listener(Listener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_remove_listener(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);
  {
    try {
      (arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_render_system_events

  call-seq:
    get_render_system_events -> StringVector

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_render_system_events(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);
  {
    try {
      result = (Ogre::StringVector *) &((Ogre::RenderSystem const *)arg1)->getRenderSystemEvents();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.pre_extra_threads_started

  call-seq:
    pre_extra_threads_started

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_pre_extra_threads_started(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);
  {
    try {
      (arg1)->preExtraThreadsStarted();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.post_extra_threads_started

  call-seq:
    post_extra_threads_started

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_post_extra_threads_started(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);
  {
    try {
      (arg1)->postExtraThreadsStarted();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.register_thread

  call-seq:
    register_thread

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_register_thread(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);
  {
    try {
      (arg1)->registerThread();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.unregister_thread

  call-seq:
    unregister_thread

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_unregister_thread(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);
  {
    try {
      (arg1)->unregisterThread();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_display_monitor_count

  call-seq:
    get_display_monitor_count -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_display_monitor_count(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);
  {
    try {
      result = (unsigned int)((Ogre::RenderSystem const *)arg1)->getDisplayMonitorCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.begin_profile_event

  call-seq:
    begin_profile_event(String eventName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_begin_profile_event(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 *","beginProfileEvent", 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 &","beginProfileEvent", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","beginProfileEvent", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->beginProfileEvent((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.end_profile_event

  call-seq:
    end_profile_event

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_end_profile_event(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 *","endProfileEvent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  {
    try {
      (arg1)->endProfileEvent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.mark_profile_event

  call-seq:
    mark_profile_event(String event)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_mark_profile_event(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 *","markProfileEvent", 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 &","markProfileEvent", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","markProfileEvent", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->markProfileEvent((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystem.get_config_option_hash

  call-seq:
    get_config_option_hash -> VALUE

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystem_get_config_option_hash(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);
  {
    try {
      result = (VALUE)Ogre_RenderSystem_getConfigOptionHash(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = result;
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::CompositionPass

  Proxy of C++ Ogre::CompositionPass class


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


/*
  Document-method: Ogre::CompositionPass.new

  call-seq:
    CompositionPass.new(CompositionTargetPass parent)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::CompositionPass *)new Ogre::CompositionPass(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositionPass(Ogre::CompositionPass *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PassType.PT_CLEAR

  call-seq:
    PT_CLEAR -> int

A class method.

*/

/*
  Document-method: Ogre::PassType.PT_STENCIL

  call-seq:
    PT_STENCIL -> int

A class method.

*/

/*
  Document-method: Ogre::PassType.PT_RENDERSCENE

  call-seq:
    PT_RENDERSCENE -> int

A class method.

*/

/*
  Document-method: Ogre::PassType.PT_RENDERQUAD

  call-seq:
    PT_RENDERQUAD -> int

A class method.

*/

/*
  Document-method: Ogre::PassType.PT_RENDERCUSTOM

  call-seq:
    PT_RENDERCUSTOM -> int

A class method.

*/

/*
  Document-method: Ogre::CompositionPass.set_type

  call-seq:
    set_type(PassType type)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_type(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);
  {
    try {
      (arg1)->setType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_type

  call-seq:
    get_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_type(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);
  {
    try {
      result = (Ogre::CompositionPass::PassType)((Ogre::CompositionPass const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_identifier

  call-seq:
    set_identifier(uint32 id)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_identifier(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);
  {
    try {
      (arg1)->setIdentifier(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_identifier

  call-seq:
    get_identifier -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_identifier(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::CompositionPass const *)arg1)->getIdentifier();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_material

  call-seq:
    set_material(MaterialPtr mat)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_material(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);
  {
    try {
      (arg1)->setMaterial((Ogre::MaterialPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_material_name

  call-seq:
    set_material_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_material_name(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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::CompositionPass const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_first_render_queue

  call-seq:
    set_first_render_queue(uint8 id)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_first_render_queue(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);
  {
    try {
      (arg1)->setFirstRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_first_render_queue

  call-seq:
    get_first_render_queue -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_first_render_queue(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::CompositionPass const *)arg1)->getFirstRenderQueue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_last_render_queue

  call-seq:
    set_last_render_queue(uint8 id)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_last_render_queue(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);
  {
    try {
      (arg1)->setLastRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_last_render_queue

  call-seq:
    get_last_render_queue -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_last_render_queue(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::CompositionPass const *)arg1)->getLastRenderQueue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_material_scheme

  call-seq:
    set_material_scheme(String schemeName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_material_scheme(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;
  }
  {
    try {
      (arg1)->setMaterialScheme((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_material_scheme

  call-seq:
    get_material_scheme -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_material_scheme(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::CompositionPass const *)arg1)->getMaterialScheme();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_clear_buffers

  call-seq:
    set_clear_buffers(uint32 val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_clear_buffers(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);
  {
    try {
      (arg1)->setClearBuffers(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_clear_buffers

  call-seq:
    get_clear_buffers -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_clear_buffers(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::CompositionPass const *)arg1)->getClearBuffers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_clear_colour

  call-seq:
    set_clear_colour(ColourValue val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_clear_colour(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));
    }
  }
  {
    try {
      (arg1)->setClearColour(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_clear_colour

  call-seq:
    get_clear_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_clear_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::CompositionPass const *)arg1)->getClearColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_clear_depth

  call-seq:
    set_clear_depth(Real depth)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_clear_depth(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);
  {
    try {
      (arg1)->setClearDepth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_clear_depth

  call-seq:
    get_clear_depth -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_clear_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::CompositionPass const *)arg1)->getClearDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_clear_stencil

  call-seq:
    set_clear_stencil(uint32 value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_clear_stencil(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);
  {
    try {
      (arg1)->setClearStencil(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_clear_stencil

  call-seq:
    get_clear_stencil -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_clear_stencil(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::CompositionPass const *)arg1)->getClearStencil();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_stencil_check

  call-seq:
    set_stencil_check(bool value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_stencil_check(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);
  {
    try {
      (arg1)->setStencilCheck(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_stencil_check

  call-seq:
    get_stencil_check -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_stencil_check(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);
  {
    try {
      result = (bool)((Ogre::CompositionPass const *)arg1)->getStencilCheck();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_stencil_func

  call-seq:
    set_stencil_func(CompareFunction value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_stencil_func(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);
  {
    try {
      (arg1)->setStencilFunc(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_stencil_func

  call-seq:
    get_stencil_func -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_stencil_func(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);
  {
    try {
      result = (Ogre::CompareFunction)((Ogre::CompositionPass const *)arg1)->getStencilFunc();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_stencil_ref_value

  call-seq:
    set_stencil_ref_value(uint32 value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_stencil_ref_value(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);
  {
    try {
      (arg1)->setStencilRefValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_stencil_ref_value

  call-seq:
    get_stencil_ref_value -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_stencil_ref_value(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::CompositionPass const *)arg1)->getStencilRefValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_stencil_mask

  call-seq:
    set_stencil_mask(uint32 value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_stencil_mask(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);
  {
    try {
      (arg1)->setStencilMask(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_stencil_mask

  call-seq:
    get_stencil_mask -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_stencil_mask(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::CompositionPass const *)arg1)->getStencilMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_stencil_fail_op

  call-seq:
    set_stencil_fail_op(StencilOperation value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_stencil_fail_op(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);
  {
    try {
      (arg1)->setStencilFailOp(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_stencil_fail_op

  call-seq:
    get_stencil_fail_op -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_stencil_fail_op(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);
  {
    try {
      result = (Ogre::StencilOperation)((Ogre::CompositionPass const *)arg1)->getStencilFailOp();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_stencil_depth_fail_op

  call-seq:
    set_stencil_depth_fail_op(StencilOperation value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_stencil_depth_fail_op(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);
  {
    try {
      (arg1)->setStencilDepthFailOp(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_stencil_depth_fail_op

  call-seq:
    get_stencil_depth_fail_op -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_stencil_depth_fail_op(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);
  {
    try {
      result = (Ogre::StencilOperation)((Ogre::CompositionPass const *)arg1)->getStencilDepthFailOp();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_stencil_pass_op

  call-seq:
    set_stencil_pass_op(StencilOperation value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_stencil_pass_op(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);
  {
    try {
      (arg1)->setStencilPassOp(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_stencil_pass_op

  call-seq:
    get_stencil_pass_op -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_stencil_pass_op(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);
  {
    try {
      result = (Ogre::StencilOperation)((Ogre::CompositionPass const *)arg1)->getStencilPassOp();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_stencil_two_sided_operation

  call-seq:
    set_stencil_two_sided_operation(bool value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_stencil_two_sided_operation(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);
  {
    try {
      (arg1)->setStencilTwoSidedOperation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_stencil_two_sided_operation

  call-seq:
    get_stencil_two_sided_operation -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_stencil_two_sided_operation(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);
  {
    try {
      result = (bool)((Ogre::CompositionPass const *)arg1)->getStencilTwoSidedOperation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_input

  call-seq:
    set_input(size_t id, String input=BLANK, size_t mrtIndex=0)
    set_input(size_t id, String input=BLANK)
    set_input(size_t id)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_input__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);
  {
    try {
      (arg1)->setInput(arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_set_input__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;
  }
  {
    try {
      (arg1)->setInput(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_set_input__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);
  {
    try {
      (arg1)->setInput(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositionPass_set_input(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_set_input__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_set_input__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_set_input__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CompositionPass.set_input", 
    "    void CompositionPass.set_input(size_t id, Ogre::String const &input, size_t mrtIndex)\n"
    "    void CompositionPass.set_input(size_t id, Ogre::String const &input)\n"
    "    void CompositionPass.set_input(size_t id)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_input

  call-seq:
    get_input(size_t id) -> InputTex

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_input(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);
  {
    try {
      result = (Ogre::CompositionPass::InputTex *) &((Ogre::CompositionPass const *)arg1)->getInput(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionPass__InputTex, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_num_inputs

  call-seq:
    get_num_inputs -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_num_inputs(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);
  {
    try {
      result = ((Ogre::CompositionPass const *)arg1)->getNumInputs();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.clear_all_inputs

  call-seq:
    clear_all_inputs

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_clear_all_inputs(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);
  {
    try {
      (arg1)->clearAllInputs();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_parent

  call-seq:
    get_parent -> CompositionTargetPass

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_parent(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);
  {
    try {
      result = (Ogre::CompositionTargetPass *)(arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTargetPass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass._is_supported

  call-seq:
    _is_supported -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass__is_supported(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);
  {
    try {
      result = (bool)(arg1)->_isSupported();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_quad_corners

  call-seq:
    set_quad_corners(Real left, Real top, Real right, Real bottom)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_quad_corners(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);
  {
    try {
      (arg1)->setQuadCorners(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_quad_corners

  call-seq:
    get_quad_corners(Real left, Real top, Real right, Real bottom) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_quad_corners(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);
  {
    try {
      result = (bool)((Ogre::CompositionPass const *)arg1)->getQuadCorners(*arg2,*arg3,*arg4,*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_quad_far_corners

  call-seq:
    set_quad_far_corners(bool farCorners, bool farCornersViewSpace)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_quad_far_corners(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);
  {
    try {
      (arg1)->setQuadFarCorners(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_quad_far_corners

  call-seq:
    get_quad_far_corners -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_quad_far_corners(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);
  {
    try {
      result = (bool)((Ogre::CompositionPass const *)arg1)->getQuadFarCorners();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_quad_far_corners_view_space

  call-seq:
    get_quad_far_corners_view_space -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_quad_far_corners_view_space(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);
  {
    try {
      result = (bool)((Ogre::CompositionPass const *)arg1)->getQuadFarCornersViewSpace();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.set_custom_type

  call-seq:
    set_custom_type(String customType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_set_custom_type(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;
  }
  {
    try {
      (arg1)->setCustomType((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPass.get_custom_type

  call-seq:
    get_custom_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionPass_get_custom_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::CompositionPass const *)arg1)->getCustomType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::CompositionTargetPass

  Proxy of C++ Ogre::CompositionTargetPass class


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


/*
  Document-method: Ogre::CompositionTargetPass.new

  call-seq:
    CompositionTargetPass.new(CompositionTechnique parent)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::CompositionTargetPass *)new Ogre::CompositionTargetPass(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositionTargetPass(Ogre::CompositionTargetPass *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::InputMode.IM_NONE

  call-seq:
    IM_NONE -> int

A class method.

*/

/*
  Document-method: Ogre::InputMode.IM_PREVIOUS

  call-seq:
    IM_PREVIOUS -> int

A class method.

*/

/*
  Document-method: Ogre::CompositionTargetPass.set_input_mode

  call-seq:
    set_input_mode(InputMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_set_input_mode(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);
  {
    try {
      (arg1)->setInputMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.get_input_mode

  call-seq:
    get_input_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_get_input_mode(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);
  {
    try {
      result = (Ogre::CompositionTargetPass::InputMode)((Ogre::CompositionTargetPass const *)arg1)->getInputMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.set_output_name

  call-seq:
    set_output_name(String out)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_set_output_name(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;
  }
  {
    try {
      (arg1)->setOutputName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.get_output_name

  call-seq:
    get_output_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_get_output_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::CompositionTargetPass const *)arg1)->getOutputName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.set_only_initial

  call-seq:
    set_only_initial(bool value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_set_only_initial(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);
  {
    try {
      (arg1)->setOnlyInitial(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.get_only_initial

  call-seq:
    get_only_initial -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_get_only_initial(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);
  {
    try {
      result = (bool)(arg1)->getOnlyInitial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.set_visibility_mask

  call-seq:
    set_visibility_mask(uint32 mask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_set_visibility_mask(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);
  {
    try {
      (arg1)->setVisibilityMask(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.get_visibility_mask

  call-seq:
    get_visibility_mask -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_get_visibility_mask(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);
  {
    try {
      result = (Ogre::uint32)(arg1)->getVisibilityMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.set_material_scheme

  call-seq:
    set_material_scheme(String schemeName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_set_material_scheme(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;
  }
  {
    try {
      (arg1)->setMaterialScheme((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.get_material_scheme

  call-seq:
    get_material_scheme -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_get_material_scheme(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::CompositionTargetPass const *)arg1)->getMaterialScheme();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.set_shadows_enabled

  call-seq:
    set_shadows_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_set_shadows_enabled(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);
  {
    try {
      (arg1)->setShadowsEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.get_shadows_enabled

  call-seq:
    get_shadows_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_get_shadows_enabled(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);
  {
    try {
      result = (bool)((Ogre::CompositionTargetPass const *)arg1)->getShadowsEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.set_lod_bias

  call-seq:
    set_lod_bias(float bias)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_set_lod_bias(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);
  {
    try {
      (arg1)->setLodBias(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.get_lod_bias

  call-seq:
    get_lod_bias -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_get_lod_bias(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);
  {
    try {
      result = (float)(arg1)->getLodBias();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.create_pass

  call-seq:
    create_pass -> CompositionPass

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_create_pass(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);
  {
    try {
      result = (Ogre::CompositionPass *)(arg1)->createPass();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionPass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.remove_pass

  call-seq:
    remove_pass(size_t idx)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_remove_pass(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);
  {
    try {
      (arg1)->removePass(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.get_pass

  call-seq:
    get_pass(size_t idx) -> CompositionPass

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_get_pass(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);
  {
    try {
      result = (Ogre::CompositionPass *)(arg1)->getPass(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionPass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.get_num_passes

  call-seq:
    get_num_passes -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_get_num_passes(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);
  {
    try {
      result = (arg1)->getNumPasses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.remove_all_passes

  call-seq:
    remove_all_passes

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_remove_all_passes(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);
  {
    try {
      (arg1)->removeAllPasses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass.get_pass_iterator

  call-seq:
    get_pass_iterator -> PassIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_get_pass_iterator(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);
  {
    try {
      result = (arg1)->getPassIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::CompositionTargetPass.get_parent

  call-seq:
    get_parent -> CompositionTechnique

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass_get_parent(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);
  {
    try {
      result = (Ogre::CompositionTechnique *)(arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPass._is_supported

  call-seq:
    _is_supported -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTargetPass__is_supported(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);
  {
    try {
      result = (bool)(arg1)->_isSupported();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::CompositionTechnique

  Proxy of C++ Ogre::CompositionTechnique class


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


/*
  Document-method: Ogre::CompositionTechnique.new

  call-seq:
    CompositionTechnique.new(Compositor parent)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::CompositionTechnique *)new Ogre::CompositionTechnique(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositionTechnique(Ogre::CompositionTechnique *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::TextureScope.TS_LOCAL

  call-seq:
    TS_LOCAL -> int

A class method.

*/

/*
  Document-method: Ogre::TextureScope.TS_CHAIN

  call-seq:
    TS_CHAIN -> int

A class method.

*/

/*
  Document-method: Ogre::TextureScope.TS_GLOBAL

  call-seq:
    TS_GLOBAL -> int

A class method.

*/

/*
  Document-method: Ogre::CompositionTechnique.create_texture_definition

  call-seq:
    create_texture_definition(String name) -> TextureDefinition

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_create_texture_definition(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;
  }
  {
    try {
      result = (Ogre::CompositionTechnique::TextureDefinition *)(arg1)->createTextureDefinition((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique__TextureDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.remove_texture_definition

  call-seq:
    remove_texture_definition(size_t idx)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_remove_texture_definition(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);
  {
    try {
      (arg1)->removeTextureDefinition(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.get_texture_definition

  call-seq:
    get_texture_definition(size_t idx) -> TextureDefinition
    get_texture_definition(String name) -> TextureDefinition

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_get_texture_definition__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);
  {
    try {
      result = (Ogre::CompositionTechnique::TextureDefinition *)(arg1)->getTextureDefinition(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique__TextureDefinition, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_get_texture_definition__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;
  }
  {
    try {
      result = (Ogre::CompositionTechnique::TextureDefinition *)(arg1)->getTextureDefinition((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_texture_definition(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_get_texture_definition__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_get_texture_definition__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "CompositionTechnique.get_texture_definition", 
    "    Ogre::CompositionTechnique::TextureDefinition * CompositionTechnique.get_texture_definition(size_t idx)\n"
    "    Ogre::CompositionTechnique::TextureDefinition * CompositionTechnique.get_texture_definition(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.get_num_texture_definitions

  call-seq:
    get_num_texture_definitions -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_get_num_texture_definitions(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);
  {
    try {
      result = (arg1)->getNumTextureDefinitions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.remove_all_texture_definitions

  call-seq:
    remove_all_texture_definitions

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_remove_all_texture_definitions(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);
  {
    try {
      (arg1)->removeAllTextureDefinitions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.get_texture_definition_iterator

  call-seq:
    get_texture_definition_iterator -> TextureDefinitionIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_get_texture_definition_iterator(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);
  {
    try {
      result = (arg1)->getTextureDefinitionIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::CompositionTechnique.create_target_pass

  call-seq:
    create_target_pass -> CompositionTargetPass

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_create_target_pass(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);
  {
    try {
      result = (Ogre::CompositionTargetPass *)(arg1)->createTargetPass();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTargetPass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.remove_target_pass

  call-seq:
    remove_target_pass(size_t idx)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_remove_target_pass(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);
  {
    try {
      (arg1)->removeTargetPass(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.get_target_pass

  call-seq:
    get_target_pass(size_t idx) -> CompositionTargetPass

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_get_target_pass(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);
  {
    try {
      result = (Ogre::CompositionTargetPass *)(arg1)->getTargetPass(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTargetPass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.get_num_target_passes

  call-seq:
    get_num_target_passes -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_get_num_target_passes(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);
  {
    try {
      result = (arg1)->getNumTargetPasses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.remove_all_target_passes

  call-seq:
    remove_all_target_passes

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_remove_all_target_passes(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);
  {
    try {
      (arg1)->removeAllTargetPasses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.get_target_pass_iterator

  call-seq:
    get_target_pass_iterator -> TargetPassIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_get_target_pass_iterator(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);
  {
    try {
      result = (arg1)->getTargetPassIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::CompositionTechnique.get_output_target_pass

  call-seq:
    get_output_target_pass -> CompositionTargetPass

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_get_output_target_pass(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);
  {
    try {
      result = (Ogre::CompositionTargetPass *)(arg1)->getOutputTargetPass();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTargetPass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.is_supported

  call-seq:
    is_supported(bool allowTextureDegradation) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_is_supported(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);
  {
    try {
      result = (bool)(arg1)->isSupported(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.set_scheme_name

  call-seq:
    set_scheme_name(String schemeName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_set_scheme_name(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;
  }
  {
    try {
      (arg1)->setSchemeName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.get_scheme_name

  call-seq:
    get_scheme_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_get_scheme_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::CompositionTechnique const *)arg1)->getSchemeName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.set_compositor_logic_name

  call-seq:
    set_compositor_logic_name(String compositorLogicName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_set_compositor_logic_name(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;
  }
  {
    try {
      (arg1)->setCompositorLogicName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.get_compositor_logic_name

  call-seq:
    get_compositor_logic_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_get_compositor_logic_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::CompositionTechnique const *)arg1)->getCompositorLogicName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechnique.get_parent

  call-seq:
    get_parent -> Compositor

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositionTechnique_get_parent(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);
  {
    try {
      result = (Ogre::Compositor *)(arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Compositor, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Compositor < Ogre::Ogre::Resource

  Proxy of C++ Ogre::Compositor class


*/
swig_class SwigClassCompositor;


/*
  Document-method: Ogre::Compositor.new

  call-seq:
    Compositor.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual=false, 
    ManualResourceLoader loader=0)
    Compositor.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual=false)
    Compositor.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Compositor *)new Ogre::Compositor(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Compositor *)new Ogre::Compositor(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Compositor *)new Ogre::Compositor(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::Compositor.create_technique

  call-seq:
    create_technique -> CompositionTechnique

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_create_technique(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);
  {
    try {
      result = (Ogre::CompositionTechnique *)(arg1)->createTechnique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Compositor.remove_technique

  call-seq:
    remove_technique(size_t idx)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_remove_technique(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);
  {
    try {
      (arg1)->removeTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Compositor.get_technique

  call-seq:
    get_technique(size_t idx) -> CompositionTechnique

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_get_technique(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);
  {
    try {
      result = (Ogre::CompositionTechnique *)(arg1)->getTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Compositor.get_num_techniques

  call-seq:
    get_num_techniques -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_get_num_techniques(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);
  {
    try {
      result = (arg1)->getNumTechniques();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Compositor.remove_all_techniques

  call-seq:
    remove_all_techniques

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_remove_all_techniques(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);
  {
    try {
      (arg1)->removeAllTechniques();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Compositor.get_technique_iterator

  call-seq:
    get_technique_iterator -> TechniqueIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_get_technique_iterator(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);
  {
    try {
      result = (arg1)->getTechniqueIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Compositor.get_supported_technique

  call-seq:
    get_supported_technique(size_t idx) -> CompositionTechnique
    get_supported_technique(String schemeName=BLANK) -> CompositionTechnique
    get_supported_technique -> CompositionTechnique

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_get_supported_technique__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);
  {
    try {
      result = (Ogre::CompositionTechnique *)(arg1)->getSupportedTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Compositor.get_num_supported_techniques

  call-seq:
    get_num_supported_techniques -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_get_num_supported_techniques(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);
  {
    try {
      result = (arg1)->getNumSupportedTechniques();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Compositor.get_supported_technique_iterator

  call-seq:
    get_supported_technique_iterator -> TechniqueIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_get_supported_technique_iterator(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);
  {
    try {
      result = (arg1)->getSupportedTechniqueIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Compositor.get_supported_technique

  call-seq:
    get_supported_technique(size_t idx) -> CompositionTechnique
    get_supported_technique(String schemeName=BLANK) -> CompositionTechnique
    get_supported_technique -> CompositionTechnique

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_get_supported_technique__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;
  }
  {
    try {
      result = (Ogre::CompositionTechnique *)(arg1)->getSupportedTechnique((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_supported_technique__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);
  {
    try {
      result = (Ogre::CompositionTechnique *)(arg1)->getSupportedTechnique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Compositor_get_supported_technique(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_get_supported_technique__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_get_supported_technique__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_get_supported_technique__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Compositor.get_supported_technique", 
    "    Ogre::CompositionTechnique * Compositor.get_supported_technique(size_t idx)\n"
    "    Ogre::CompositionTechnique * Compositor.get_supported_technique(Ogre::String const &schemeName)\n"
    "    Ogre::CompositionTechnique * Compositor.get_supported_technique()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Compositor.get_texture_instance_name

  call-seq:
    get_texture_instance_name(String name, size_t mrtIndex) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_get_texture_instance_name(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);
  {
    try {
      result = (Ogre::String *) &(arg1)->getTextureInstanceName((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::Compositor.get_texture_instance

  call-seq:
    get_texture_instance(String name, size_t mrtIndex) -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_get_texture_instance(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);
  {
    try {
      result = (arg1)->getTextureInstance((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
}



/*
  Document-method: Ogre::Compositor.get_render_target

  call-seq:
    get_render_target(String name) -> RenderTarget

An instance method.

*/
SWIGINTERN VALUE
_wrap_Compositor_get_render_target(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;
  }
  {
    try {
      result = (Ogre::RenderTarget *)(arg1)->getRenderTarget((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-class: Ogre::CompositorPtr

  Proxy of C++ Ogre::CompositorPtr class


*/
swig_class SwigClassCompositorPtr;


/*
  Document-method: Ogre::CompositorPtr.new

  call-seq:
    CompositorPtr.new
    CompositorPtr.new(Compositor rep)
    CompositorPtr.new(CompositorPtr r)
    CompositorPtr.new(ResourcePtr r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::CompositorPtr *)new Ogre::CompositorPtr();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::CompositorPtr *)new Ogre::CompositorPtr(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::CompositorPtr *)new Ogre::CompositorPtr((Ogre::CompositorPtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::CompositorPtr *)new Ogre::CompositorPtr((Ogre::ResourcePtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::RenderTargetEvent

  Proxy of C++ Ogre::RenderTargetEvent class


*/
swig_class SwigClassRenderTargetEvent;


/*
  Document-method: Ogre::RenderTargetEvent.source

  call-seq:
    source -> RenderTarget

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderTargetEvent.source=

  call-seq:
    source=(x) -> RenderTarget

Set new value for attribute.

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


/*
  Document-method: Ogre::RenderTargetEvent.new

  call-seq:
    RenderTargetEvent.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderTargetEvent *)new Ogre::RenderTargetEvent();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderTargetEvent(Ogre::RenderTargetEvent *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::RenderTargetViewportEvent

  Proxy of C++ Ogre::RenderTargetViewportEvent class


*/
swig_class SwigClassRenderTargetViewportEvent;


/*
  Document-method: Ogre::RenderTargetViewportEvent.source

  call-seq:
    source -> Viewport

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderTargetViewportEvent.source=

  call-seq:
    source=(x) -> Viewport

Set new value for attribute.

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


/*
  Document-method: Ogre::RenderTargetViewportEvent.new

  call-seq:
    RenderTargetViewportEvent.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderTargetViewportEvent *)new Ogre::RenderTargetViewportEvent();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderTargetViewportEvent(Ogre::RenderTargetViewportEvent *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::RenderTargetListener

  Proxy of C++ Ogre::RenderTargetListener class


*/
swig_class SwigClassRenderTargetListener;

SWIGINTERN void
free_Ogre_RenderTargetListener(Ogre::RenderTargetListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderTargetListener.pre_render_target_update

  call-seq:
    pre_render_target_update(RenderTargetEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTargetListener_pre_render_target_update(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::RenderTargetListener::preRenderTargetUpdate((Ogre::RenderTargetEvent const &)*arg2);
        } else {
          (arg1)->preRenderTargetUpdate((Ogre::RenderTargetEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTargetListener.post_render_target_update

  call-seq:
    post_render_target_update(RenderTargetEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTargetListener_post_render_target_update(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::RenderTargetListener::postRenderTargetUpdate((Ogre::RenderTargetEvent const &)*arg2);
        } else {
          (arg1)->postRenderTargetUpdate((Ogre::RenderTargetEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTargetListener.pre_viewport_update

  call-seq:
    pre_viewport_update(RenderTargetViewportEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTargetListener_pre_viewport_update(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::RenderTargetListener::preViewportUpdate((Ogre::RenderTargetViewportEvent const &)*arg2);
        } else {
          (arg1)->preViewportUpdate((Ogre::RenderTargetViewportEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTargetListener.post_viewport_update

  call-seq:
    post_viewport_update(RenderTargetViewportEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTargetListener_post_viewport_update(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::RenderTargetListener::postViewportUpdate((Ogre::RenderTargetViewportEvent const &)*arg2);
        } else {
          (arg1)->postViewportUpdate((Ogre::RenderTargetViewportEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTargetListener.viewport_added

  call-seq:
    viewport_added(RenderTargetViewportEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTargetListener_viewport_added(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::RenderTargetListener::viewportAdded((Ogre::RenderTargetViewportEvent const &)*arg2);
        } else {
          (arg1)->viewportAdded((Ogre::RenderTargetViewportEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderTargetListener.viewport_removed

  call-seq:
    viewport_removed(RenderTargetViewportEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderTargetListener_viewport_removed(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::RenderTargetListener::viewportRemoved((Ogre::RenderTargetViewportEvent const &)*arg2);
        } else {
          (arg1)->viewportRemoved((Ogre::RenderTargetViewportEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } 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;
  }
  


/*
  Document-method: Ogre::RenderTargetListener.new

  call-seq:
    RenderTargetListener.new

Class constructor.

*/
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;
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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;
}



/*
  Document-class: Ogre::RenderQueueListener

  Proxy of C++ Ogre::RenderQueueListener class


*/
swig_class SwigClassRenderQueueListener;

SWIGINTERN void
free_Ogre_RenderQueueListener(Ogre::RenderQueueListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderQueueListener.pre_render_queues

  call-seq:
    pre_render_queues

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueListener_pre_render_queues(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::RenderQueueListener::preRenderQueues();
        } else {
          (arg1)->preRenderQueues();
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueListener.post_render_queues

  call-seq:
    post_render_queues

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueListener_post_render_queues(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::RenderQueueListener::postRenderQueues();
        } else {
          (arg1)->postRenderQueues();
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueListener.render_queue_started

  call-seq:
    render_queue_started(uint8 queueGroupId, String invocation, bool skipThisInvocation)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueListener_render_queue_started(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::RenderQueueListener::renderQueueStarted(arg2,(Ogre::String const &)*arg3,*arg4);
        } else {
          (arg1)->renderQueueStarted(arg2,(Ogre::String const &)*arg3,*arg4);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } 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;
}



/*
  Document-method: Ogre::RenderQueueListener.render_queue_ended

  call-seq:
    render_queue_ended(uint8 queueGroupId, String invocation, bool repeatThisInvocation)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueListener_render_queue_ended(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::RenderQueueListener::renderQueueEnded(arg2,(Ogre::String const &)*arg3,*arg4);
        } else {
          (arg1)->renderQueueEnded(arg2,(Ogre::String const &)*arg3,*arg4);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } 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;
  }
  


/*
  Document-method: Ogre::RenderQueueListener.new

  call-seq:
    RenderQueueListener.new

Class constructor.

*/
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;
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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;
}



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

  call-seq:
    RENDER_QUEUE_COUNT -> size_t

Get value of attribute.

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



/*
  Document-class: Ogre::CompositorInstance

  Proxy of C++ Ogre::CompositorInstance class


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


/*
  Document-method: Ogre::CompositorInstance.new

  call-seq:
    CompositorInstance.new(CompositionTechnique technique, CompositorChain chain)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::CompositorInstance *)new Ogre::CompositorInstance(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositorInstance(Ogre::CompositorInstance *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::CompositorInstance.set_enabled

  call-seq:
    set_enabled(bool value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_set_enabled(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);
  {
    try {
      (arg1)->setEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.get_enabled

  call-seq:
    get_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_get_enabled(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);
  {
    try {
      result = (bool)((Ogre::CompositorInstance const *)arg1)->getEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.set_alive

  call-seq:
    set_alive(bool value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_set_alive(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);
  {
    try {
      (arg1)->setAlive(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.get_alive

  call-seq:
    get_alive -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_get_alive(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);
  {
    try {
      result = (bool)((Ogre::CompositorInstance const *)arg1)->getAlive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.get_texture_instance_name

  call-seq:
    get_texture_instance_name(String name, size_t mrtIndex) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_get_texture_instance_name(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);
  {
    try {
      result = (Ogre::String *) &(arg1)->getTextureInstanceName((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::CompositorInstance.get_texture_instance

  call-seq:
    get_texture_instance(String name, size_t mrtIndex) -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_get_texture_instance(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);
  {
    try {
      result = (arg1)->getTextureInstance((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
}



/*
  Document-method: Ogre::CompositorInstance.get_render_target

  call-seq:
    get_render_target(String name) -> RenderTarget

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_get_render_target(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;
  }
  {
    try {
      result = (Ogre::RenderTarget *)(arg1)->getRenderTarget((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance._compile_target_operations

  call-seq:
    _compile_target_operations(CompiledState compiledState)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance__compile_target_operations(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);
  {
    try {
      (arg1)->_compileTargetOperations(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance._compile_output_operation

  call-seq:
    _compile_output_operation(TargetOperation finalState)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance__compile_output_operation(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);
  {
    try {
      (arg1)->_compileOutputOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.get_compositor

  call-seq:
    get_compositor -> Compositor

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_get_compositor(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);
  {
    try {
      result = (Ogre::Compositor *)(arg1)->getCompositor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Compositor, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.get_technique

  call-seq:
    get_technique -> CompositionTechnique

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_get_technique(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);
  {
    try {
      result = (Ogre::CompositionTechnique *)(arg1)->getTechnique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.set_technique

  call-seq:
    set_technique(CompositionTechnique tech, bool reuseTextures=true)
    set_technique(CompositionTechnique tech)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_set_technique__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);
  {
    try {
      (arg1)->setTechnique(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_set_technique__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);
  {
    try {
      (arg1)->setTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorInstance_set_technique(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_set_technique__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_set_technique__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "CompositorInstance.set_technique", 
    "    void CompositorInstance.set_technique(Ogre::CompositionTechnique *tech, bool reuseTextures)\n"
    "    void CompositorInstance.set_technique(Ogre::CompositionTechnique *tech)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.set_scheme

  call-seq:
    set_scheme(String schemeName, bool reuseTextures=true)
    set_scheme(String schemeName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_set_scheme__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);
  {
    try {
      (arg1)->setScheme((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_set_scheme__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;
  }
  {
    try {
      (arg1)->setScheme((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorInstance_set_scheme(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_set_scheme__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_set_scheme__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "CompositorInstance.set_scheme", 
    "    void CompositorInstance.set_scheme(Ogre::String const &schemeName, bool reuseTextures)\n"
    "    void CompositorInstance.set_scheme(Ogre::String const &schemeName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.get_scheme

  call-seq:
    get_scheme -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_get_scheme(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::CompositorInstance const *)arg1)->getScheme();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.notify_resized

  call-seq:
    notify_resized

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_notify_resized(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);
  {
    try {
      (arg1)->notifyResized();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.get_chain

  call-seq:
    get_chain -> CompositorChain

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_get_chain(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);
  {
    try {
      result = (Ogre::CompositorChain *)(arg1)->getChain();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorChain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.add_listener

  call-seq:
    add_listener(Listener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_add_listener(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);
  {
    try {
      (arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance.remove_listener

  call-seq:
    remove_listener(Listener l)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance_remove_listener(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);
  {
    try {
      (arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance._fire_notify_material_setup

  call-seq:
    _fire_notify_material_setup(uint32 pass_id, MaterialPtr mat)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance__fire_notify_material_setup(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);
  {
    try {
      (arg1)->_fireNotifyMaterialSetup(arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance._fire_notify_material_render

  call-seq:
    _fire_notify_material_render(uint32 pass_id, MaterialPtr mat)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance__fire_notify_material_render(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);
  {
    try {
      (arg1)->_fireNotifyMaterialRender(arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorInstance._fire_notify_resources_created

  call-seq:
    _fire_notify_resources_created(bool forResizeOnly)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorInstance__fire_notify_resources_created(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);
  {
    try {
      (arg1)->_fireNotifyResourcesCreated(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::CompositorChain < Ogre::Ogre::RenderTargetListener

  Proxy of C++ Ogre::CompositorChain class


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


/*
  Document-method: Ogre::CompositorChain.new

  call-seq:
    CompositorChain.new(Viewport vp)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::CompositorChain *)new Ogre::CompositorChain(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositorChain(Ogre::CompositorChain *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::CompositorChain.LAST

  call-seq:
    LAST -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::CompositorChain.LAST

  call-seq:
    LAST -> size_t

A class method.

*/

/*
  Document-method: Ogre::CompositorChain.BEST

  call-seq:
    BEST -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::CompositorChain.BEST

  call-seq:
    BEST -> size_t

A class method.

*/

/*
  Document-method: Ogre::CompositorChain.add_compositor

  call-seq:
    add_compositor(CompositorPtr filter, size_t addPosition=LAST, String scheme=BLANK) -> CompositorInstance
    add_compositor(CompositorPtr filter, size_t addPosition=LAST) -> CompositorInstance
    add_compositor(CompositorPtr filter) -> CompositorInstance

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_add_compositor__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;
  }
  {
    try {
      result = (Ogre::CompositorInstance *)(arg1)->addCompositor(arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_add_compositor__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);
  {
    try {
      result = (Ogre::CompositorInstance *)(arg1)->addCompositor(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_add_compositor__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));
    }
  }
  {
    try {
      result = (Ogre::CompositorInstance *)(arg1)->addCompositor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorChain_add_compositor(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_add_compositor__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_add_compositor__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_add_compositor__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CompositorChain.add_compositor", 
    "    Ogre::CompositorInstance * CompositorChain.add_compositor(Ogre::CompositorPtr filter, size_t addPosition, Ogre::String const &scheme)\n"
    "    Ogre::CompositorInstance * CompositorChain.add_compositor(Ogre::CompositorPtr filter, size_t addPosition)\n"
    "    Ogre::CompositorInstance * CompositorChain.add_compositor(Ogre::CompositorPtr filter)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.remove_compositor

  call-seq:
    remove_compositor(size_t position=LAST)
    remove_compositor

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_remove_compositor__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);
  {
    try {
      (arg1)->removeCompositor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_remove_compositor__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);
  {
    try {
      (arg1)->removeCompositor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorChain_remove_compositor(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_remove_compositor__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_remove_compositor__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "CompositorChain.remove_compositor", 
    "    void CompositorChain.remove_compositor(size_t position)\n"
    "    void CompositorChain.remove_compositor()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.get_num_compositors

  call-seq:
    get_num_compositors -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_get_num_compositors(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);
  {
    try {
      result = (arg1)->getNumCompositors();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.remove_all_compositors

  call-seq:
    remove_all_compositors

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_remove_all_compositors(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);
  {
    try {
      (arg1)->removeAllCompositors();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.get_compositor

  call-seq:
    get_compositor(size_t index) -> CompositorInstance
    get_compositor(String name) -> CompositorInstance

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_get_compositor__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);
  {
    try {
      result = (Ogre::CompositorInstance *)(arg1)->getCompositor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_get_compositor__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;
  }
  {
    try {
      result = (Ogre::CompositorInstance *)(arg1)->getCompositor((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_compositor(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_get_compositor__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_get_compositor__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "CompositorChain.get_compositor", 
    "    Ogre::CompositorInstance * CompositorChain.get_compositor(size_t index)\n"
    "    Ogre::CompositorInstance * CompositorChain.get_compositor(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain._get_original_scene_compositor

  call-seq:
    _get_original_scene_compositor -> CompositorInstance

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain__get_original_scene_compositor(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);
  {
    try {
      result = (Ogre::CompositorInstance *)(arg1)->_getOriginalSceneCompositor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.get_compositors

  call-seq:
    get_compositors -> InstanceIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_get_compositors(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);
  {
    try {
      result = (arg1)->getCompositors();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::CompositorChain.set_compositor_enabled

  call-seq:
    set_compositor_enabled(size_t position, bool state)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_set_compositor_enabled(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);
  {
    try {
      (arg1)->setCompositorEnabled(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.pre_render_target_update

  call-seq:
    pre_render_target_update(RenderTargetEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_pre_render_target_update(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);
  {
    try {
      (arg1)->preRenderTargetUpdate((Ogre::RenderTargetEvent const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.post_render_target_update

  call-seq:
    post_render_target_update(RenderTargetEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_post_render_target_update(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);
  {
    try {
      (arg1)->postRenderTargetUpdate((Ogre::RenderTargetEvent const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.pre_viewport_update

  call-seq:
    pre_viewport_update(RenderTargetViewportEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_pre_viewport_update(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);
  {
    try {
      (arg1)->preViewportUpdate((Ogre::RenderTargetViewportEvent const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.post_viewport_update

  call-seq:
    post_viewport_update(RenderTargetViewportEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_post_viewport_update(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);
  {
    try {
      (arg1)->postViewportUpdate((Ogre::RenderTargetViewportEvent const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.viewport_camera_changed

  call-seq:
    viewport_camera_changed(Viewport viewport)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_viewport_camera_changed(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);
  {
    try {
      (arg1)->viewportCameraChanged(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.viewport_dimensions_changed

  call-seq:
    viewport_dimensions_changed(Viewport viewport)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_viewport_dimensions_changed(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);
  {
    try {
      (arg1)->viewportDimensionsChanged(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.viewport_destroyed

  call-seq:
    viewport_destroyed(Viewport viewport)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_viewport_destroyed(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);
  {
    try {
      (arg1)->viewportDestroyed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain._mark_dirty

  call-seq:
    _mark_dirty

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain__mark_dirty(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);
  {
    try {
      (arg1)->_markDirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.get_viewport

  call-seq:
    get_viewport -> Viewport

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_get_viewport(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);
  {
    try {
      result = (Ogre::Viewport *)(arg1)->getViewport();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain._remove_instance

  call-seq:
    _remove_instance(CompositorInstance i)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain__remove_instance(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);
  {
    try {
      (arg1)->_removeInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain._queued_operation

  call-seq:
    _queued_operation(RenderSystemOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain__queued_operation(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);
  {
    try {
      (arg1)->_queuedOperation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain._compile

  call-seq:
    _compile

An instance method.

*/
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);
  {
    try {
      (arg1)->_compile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.get_previous_instance

  call-seq:
    get_previous_instance(CompositorInstance curr, bool activeOnly=true) -> CompositorInstance
    get_previous_instance(CompositorInstance curr) -> CompositorInstance

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_get_previous_instance__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);
  {
    try {
      result = (Ogre::CompositorInstance *)(arg1)->getPreviousInstance(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_get_previous_instance__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);
  {
    try {
      result = (Ogre::CompositorInstance *)(arg1)->getPreviousInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorChain_get_previous_instance(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_get_previous_instance__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_get_previous_instance__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "CompositorChain.get_previous_instance", 
    "    Ogre::CompositorInstance * CompositorChain.get_previous_instance(Ogre::CompositorInstance *curr, bool activeOnly)\n"
    "    Ogre::CompositorInstance * CompositorChain.get_previous_instance(Ogre::CompositorInstance *curr)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::CompositorChain.get_next_instance

  call-seq:
    get_next_instance(CompositorInstance curr, bool activeOnly=true) -> CompositorInstance
    get_next_instance(CompositorInstance curr) -> CompositorInstance

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorChain_get_next_instance__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);
  {
    try {
      result = (Ogre::CompositorInstance *)(arg1)->getNextInstance(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_get_next_instance__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);
  {
    try {
      result = (Ogre::CompositorInstance *)(arg1)->getNextInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorChain_get_next_instance(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_get_next_instance__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_get_next_instance__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "CompositorChain.get_next_instance", 
    "    Ogre::CompositorInstance * CompositorChain.get_next_instance(Ogre::CompositorInstance *curr, bool activeOnly)\n"
    "    Ogre::CompositorInstance * CompositorChain.get_next_instance(Ogre::CompositorInstance *curr)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::CompositorLogic

  Proxy of C++ Ogre::CompositorLogic class


*/
swig_class SwigClassCompositorLogic;


/*
  Document-method: Ogre::CompositorLogic.compositor_instance_created

  call-seq:
    compositor_instance_created(CompositorInstance newInstance)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorLogic_compositor_instance_created(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);
  {
    try {
      (arg1)->compositorInstanceCreated(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorLogic.compositor_instance_destroyed

  call-seq:
    compositor_instance_destroyed(CompositorInstance destroyedInstance)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorLogic_compositor_instance_destroyed(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);
  {
    try {
      (arg1)->compositorInstanceDestroyed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_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;
  }
  


/*
  Document-method: Ogre::CompositorLogic.new

  call-seq:
    CompositorLogic.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::CompositorLogic *)new Ogre::CompositorLogic();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Rectangle2D

  Proxy of C++ Ogre::Rectangle2D class


*/
swig_class SwigClassRectangle2D;


/*
  Document-method: Ogre::Rectangle2D.new

  call-seq:
    Rectangle2D.new(bool includeTextureCoordinates=false, Usage vBufUsage=HBU_DYNAMIC_WRITE_ONLY)
    Rectangle2D.new(bool includeTextureCoordinates=false)
    Rectangle2D.new
    Rectangle2D.new(String name, bool includeTextureCoordinates=false, 
    Usage vBufUsage=HBU_DYNAMIC_WRITE_ONLY)
    Rectangle2D.new(String name, bool includeTextureCoordinates=false)
    Rectangle2D.new(String name)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Rectangle2D *)new Ogre::Rectangle2D(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Rectangle2D *)new Ogre::Rectangle2D(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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;
  }
  {
    try {
      result = (Ogre::Rectangle2D *)new Ogre::Rectangle2D();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::Rectangle2D *)new Ogre::Rectangle2D((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Rectangle2D *)new Ogre::Rectangle2D((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Rectangle2D *)new Ogre::Rectangle2D((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::Rectangle2D.set_corners

  call-seq:
    set_corners(Real left, Real top, Real right, Real bottom, bool updateAABB=true)
    set_corners(Real left, Real top, Real right, Real bottom)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Rectangle2D_set_corners__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);
  {
    try {
      (arg1)->setCorners(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle2D_set_corners__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);
  {
    try {
      (arg1)->setCorners(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Rectangle2D_set_corners(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_set_corners__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_set_corners__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Rectangle2D.set_corners", 
    "    void Rectangle2D.set_corners(Ogre::Real left, Ogre::Real top, Ogre::Real right, Ogre::Real bottom, bool updateAABB)\n"
    "    void Rectangle2D.set_corners(Ogre::Real left, Ogre::Real top, Ogre::Real right, Ogre::Real bottom)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Rectangle2D.set_normals

  call-seq:
    set_normals(Vector3 topLeft, Vector3 bottomLeft, Vector3 topRight, 
    Vector3 bottomRight)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Rectangle2D_set_normals(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);
  {
    try {
      (arg1)->setNormals((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4,(Ogre::Vector3 const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Rectangle2D.set_uvs

  call-seq:
    set_uvs(Vector2 topLeft, Vector2 bottomLeft, Vector2 topRight, 
    Vector2 bottomRight)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Rectangle2D_set_uvs(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);
  {
    try {
      (arg1)->setUVs((Ogre::Vector2 const &)*arg2,(Ogre::Vector2 const &)*arg3,(Ogre::Vector2 const &)*arg4,(Ogre::Vector2 const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Rectangle2D.set_default_uvs

  call-seq:
    set_default_uvs

An instance method.

*/
SWIGINTERN VALUE
_wrap_Rectangle2D_set_default_uvs(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);
  {
    try {
      (arg1)->setDefaultUVs();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Rectangle2D.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera cam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Rectangle2D_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Rectangle2D const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Rectangle2D.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Rectangle2D_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Rectangle2D const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::CompositorManager < Ogre::Ogre::ResourceManager

  Proxy of C++ Ogre::CompositorManager class


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


/*
  Document-method: Ogre::CompositorManager.new

  call-seq:
    CompositorManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::CompositorManager *)new Ogre::CompositorManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositorManager(Ogre::CompositorManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::CompositorManager.create_impl

  call-seq:
    create_impl(String name, ResourceHandle handle, String group, bool isManual, 
    ManualResourceLoader loader, NameValuePairList params) -> Resource

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_create_impl(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);
  {
    try {
      result = (Ogre::Resource *)(arg1)->createImpl((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6,(Ogre::NameValuePairList const *)arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::CompositorManager.initialise

  call-seq:
    initialise

An instance method.

*/
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);
  {
    try {
      (arg1)->initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.parse_script

  call-seq:
    parse_script(DataStreamPtr stream, String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_parse_script(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;
  }
  {
    try {
      (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.get_compositor_chain

  call-seq:
    get_compositor_chain(Viewport vp) -> CompositorChain

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_get_compositor_chain(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);
  {
    try {
      result = (Ogre::CompositorChain *)(arg1)->getCompositorChain(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorChain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.has_compositor_chain

  call-seq:
    has_compositor_chain(Viewport vp) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_has_compositor_chain(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);
  {
    try {
      result = (bool)((Ogre::CompositorManager const *)arg1)->hasCompositorChain(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.remove_compositor_chain

  call-seq:
    remove_compositor_chain(Viewport vp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_remove_compositor_chain(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);
  {
    try {
      (arg1)->removeCompositorChain(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.add_compositor

  call-seq:
    add_compositor(Viewport vp, String compositor, int addPosition=-1) -> CompositorInstance
    add_compositor(Viewport vp, String compositor) -> CompositorInstance

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_add_compositor__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);
  {
    try {
      result = (Ogre::CompositorInstance *)(arg1)->addCompositor(arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_add_compositor__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;
  }
  {
    try {
      result = (Ogre::CompositorInstance *)(arg1)->addCompositor(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_add_compositor(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_add_compositor__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_add_compositor__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CompositorManager.add_compositor", 
    "    Ogre::CompositorInstance * CompositorManager.add_compositor(Ogre::Viewport *vp, Ogre::String const &compositor, int addPosition)\n"
    "    Ogre::CompositorInstance * CompositorManager.add_compositor(Ogre::Viewport *vp, Ogre::String const &compositor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.remove_compositor

  call-seq:
    remove_compositor(Viewport vp, String compositor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_remove_compositor(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;
  }
  {
    try {
      (arg1)->removeCompositor(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.set_compositor_enabled

  call-seq:
    set_compositor_enabled(Viewport vp, String compositor, bool value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_set_compositor_enabled(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);
  {
    try {
      (arg1)->setCompositorEnabled(arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager._get_textured_rectangle_2d

  call-seq:
    _get_textured_rectangle_2d -> Renderable

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager__get_textured_rectangle_2d(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);
  {
    try {
      result = (Ogre::Renderable *)(arg1)->_getTexturedRectangle2D();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.remove_all

  call-seq:
    remove_all

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_remove_all(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);
  {
    try {
      (arg1)->removeAll();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager._reconstruct_all_compositor_resources

  call-seq:
    _reconstruct_all_compositor_resources

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager__reconstruct_all_compositor_resources(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);
  {
    try {
      (arg1)->_reconstructAllCompositorResources();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.get_pooled_texture

  call-seq:
    get_pooled_texture(String name, String localName, size_t w, size_t h, 
    PixelFormat f, uint aa, String aaHint, bool srgb, 
    UniqueTextureSet texturesAlreadyAssigned, 
    CompositorInstance inst, TextureScope scope) -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_get_pooled_texture(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);
  {
    try {
      result = (arg1)->getPooledTexture((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::String const &)*arg8,arg9,*arg10,arg11,arg12);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::CompositorManager.free_pooled_textures

  call-seq:
    free_pooled_textures(bool onlyIfUnreferenced=true)
    free_pooled_textures

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_free_pooled_textures__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);
  {
    try {
      (arg1)->freePooledTextures(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_free_pooled_textures__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);
  {
    try {
      (arg1)->freePooledTextures();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorManager_free_pooled_textures(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_free_pooled_textures__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_free_pooled_textures__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "CompositorManager.free_pooled_textures", 
    "    void CompositorManager.free_pooled_textures(bool onlyIfUnreferenced)\n"
    "    void CompositorManager.free_pooled_textures()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.register_compositor_logic

  call-seq:
    register_compositor_logic(String name, CompositorLogic logic)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_register_compositor_logic(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);
  {
    try {
      (arg1)->registerCompositorLogic((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.unregister_compositor_logic

  call-seq:
    unregister_compositor_logic(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_unregister_compositor_logic(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;
  }
  {
    try {
      (arg1)->unregisterCompositorLogic((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.get_compositor_logic

  call-seq:
    get_compositor_logic(String name) -> CompositorLogic

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_get_compositor_logic(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;
  }
  {
    try {
      result = (Ogre::CompositorLogic *)(arg1)->getCompositorLogic((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorLogic, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.register_custom_composition_pass

  call-seq:
    register_custom_composition_pass(String name, CustomCompositionPass customPass)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_register_custom_composition_pass(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);
  {
    try {
      (arg1)->registerCustomCompositionPass((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.get_custom_composition_pass

  call-seq:
    get_custom_composition_pass(String name) -> CustomCompositionPass

An instance method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_get_custom_composition_pass(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;
  }
  {
    try {
      result = (Ogre::CustomCompositionPass *)(arg1)->getCustomCompositionPass((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CustomCompositionPass, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.get_singleton

  call-seq:
    get_singleton -> CompositorManager

A class method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::CompositorManager *) &Ogre::CompositorManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> CompositorManager

A class method.

*/
SWIGINTERN VALUE
_wrap_CompositorManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::CompositorManager *)Ogre::CompositorManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ConfigFile

  Proxy of C++ Ogre::ConfigFile class


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


/*
  Document-method: Ogre::ConfigFile.new

  call-seq:
    ConfigFile.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ConfigFile *)new Ogre::ConfigFile();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ConfigFile(Ogre::ConfigFile *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ConfigFile.load

  call-seq:
    load(String filename, String separators="\t:=", bool trimWhitespace=true)
    load(String filename)
    load(String filename, String resourceGroup, String separators="\t:=", 
    bool trimWhitespace=true)
    load(String filename, String resourceGroup, String separators="\t:=")
    load(DataStreamPtr stream, String separators="\t:=", bool trimWhitespace=true)
    load(DataStreamPtr stream, String separators="\t:=")
    load(DataStreamPtr stream)

An instance method.

*/
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);
  {
    try {
      (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
  }
  {
    try {
      (arg1)->load((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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;
  }
  {
    try {
      (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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);
  {
    try {
      (arg1)->load((Ogre::DataStreamPtr const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      (arg1)->load((Ogre::DataStreamPtr const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->load((Ogre::DataStreamPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::ConfigFile.load_direct

  call-seq:
    load_direct(String filename, String separators="\t:=", bool trimWhitespace=true)
    load_direct(String filename, String separators="\t:=")
    load_direct(String filename)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConfigFile_load_direct__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);
  {
    try {
      (arg1)->loadDirect((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_direct__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;
  }
  {
    try {
      (arg1)->loadDirect((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_direct__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;
  }
  {
    try {
      (arg1)->loadDirect((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConfigFile_load_direct(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_load_direct__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_load_direct__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_load_direct__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ConfigFile.load_direct", 
    "    void ConfigFile.load_direct(Ogre::String const &filename, Ogre::String const &separators, bool trimWhitespace)\n"
    "    void ConfigFile.load_direct(Ogre::String const &filename, Ogre::String const &separators)\n"
    "    void ConfigFile.load_direct(Ogre::String const &filename)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ConfigFile.load_from_resource_system

  call-seq:
    load_from_resource_system(String filename, String resourceGroup, String separators="\t:=", 
    bool trimWhitespace=true)
    load_from_resource_system(String filename, String resourceGroup, String separators="\t:=")
    load_from_resource_system(String filename, String resourceGroup)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConfigFile_load_from_resource_system__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);
  {
    try {
      (arg1)->loadFromResourceSystem((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_from_resource_system__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;
  }
  {
    try {
      (arg1)->loadFromResourceSystem((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_from_resource_system__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;
  }
  {
    try {
      (arg1)->loadFromResourceSystem((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_from_resource_system(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_load_from_resource_system__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_load_from_resource_system__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_load_from_resource_system__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ConfigFile.load_from_resource_system", 
    "    void ConfigFile.load_from_resource_system(Ogre::String const &filename, Ogre::String const &resourceGroup, Ogre::String const &separators, bool trimWhitespace)\n"
    "    void ConfigFile.load_from_resource_system(Ogre::String const &filename, Ogre::String const &resourceGroup, Ogre::String const &separators)\n"
    "    void ConfigFile.load_from_resource_system(Ogre::String const &filename, Ogre::String const &resourceGroup)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ConfigFile.get_setting

  call-seq:
    get_setting(String key, String section=BLANK, String defaultValue=BLANK) -> String
    get_setting(String key, String section=BLANK) -> String
    get_setting(String key) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConfigFile_get_setting__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;
  }
  {
    try {
      result = ((Ogre::ConfigFile const *)arg1)->getSetting((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_get_setting__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;
  }
  {
    try {
      result = ((Ogre::ConfigFile const *)arg1)->getSetting((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_get_setting__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;
  }
  {
    try {
      result = ((Ogre::ConfigFile const *)arg1)->getSetting((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_get_setting(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_get_setting__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_get_setting__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_get_setting__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ConfigFile.get_setting", 
    "    Ogre::String ConfigFile.get_setting(Ogre::String const &key, Ogre::String const &section, Ogre::String const &defaultValue)\n"
    "    Ogre::String ConfigFile.get_setting(Ogre::String const &key, Ogre::String const &section)\n"
    "    Ogre::String ConfigFile.get_setting(Ogre::String const &key)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ConfigFile.get_multi_setting

  call-seq:
    get_multi_setting(String key, String section=BLANK) -> StringVector
    get_multi_setting(String key) -> StringVector

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConfigFile_get_multi_setting__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;
  }
  {
    try {
      result = ((Ogre::ConfigFile const *)arg1)->getMultiSetting((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_multi_setting__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;
  }
  {
    try {
      result = ((Ogre::ConfigFile const *)arg1)->getMultiSetting((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_multi_setting(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_get_multi_setting__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_get_multi_setting__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ConfigFile.get_multi_setting", 
    "    Ogre::StringVector ConfigFile.get_multi_setting(Ogre::String const &key, Ogre::String const &section)\n"
    "    Ogre::StringVector ConfigFile.get_multi_setting(Ogre::String const &key)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ConfigFile.get_section_iterator

  call-seq:
    get_section_iterator -> SectionIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConfigFile_get_section_iterator(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);
  {
    try {
      result = (arg1)->getSectionIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ConfigFile.get_settings_iterator

  call-seq:
    get_settings_iterator(String section=BLANK) -> SettingsIterator
    get_settings_iterator -> SettingsIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConfigFile_get_settings_iterator__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;
  }
  {
    try {
      result = (arg1)->getSettingsIterator((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_settings_iterator__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);
  {
    try {
      result = (arg1)->getSettingsIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_settings_iterator(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_get_settings_iterator__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_get_settings_iterator__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ConfigFile.get_settings_iterator", 
    "    Ogre::ConfigFile::SettingsIterator ConfigFile.get_settings_iterator(Ogre::String const &section)\n"
    "    Ogre::ConfigFile::SettingsIterator ConfigFile.get_settings_iterator()\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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConfigFile.each_settings

  call-seq:
    each_settings

An instance method.

*/
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);
  {
    try {
      Ogre_ConfigFile_each_Settings(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::FrameTimeControllerValue < Ogre::Ogre::FrameListener

  Proxy of C++ Ogre::FrameTimeControllerValue class


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


/*
  Document-method: Ogre::FrameTimeControllerValue.new

  call-seq:
    FrameTimeControllerValue.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::FrameTimeControllerValue *)new Ogre::FrameTimeControllerValue();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FrameTimeControllerValue.frame_ended

  call-seq:
    frame_ended(FrameEvent evt) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_frame_ended(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);
  {
    try {
      result = (bool)(arg1)->frameEnded((Ogre::FrameEvent const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FrameTimeControllerValue.frame_started

  call-seq:
    frame_started(FrameEvent evt) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_frame_started(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);
  {
    try {
      result = (bool)(arg1)->frameStarted((Ogre::FrameEvent const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FrameTimeControllerValue.get_value

  call-seq:
    get_value -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_get_value(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);
  {
    try {
      result = (Ogre::Real)((Ogre::FrameTimeControllerValue const *)arg1)->getValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FrameTimeControllerValue.set_value

  call-seq:
    set_value(Real value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_set_value(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);
  {
    try {
      (arg1)->setValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FrameTimeControllerValue.get_time_factor

  call-seq:
    get_time_factor -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_get_time_factor(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);
  {
    try {
      result = (Ogre::Real)((Ogre::FrameTimeControllerValue const *)arg1)->getTimeFactor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FrameTimeControllerValue.set_time_factor

  call-seq:
    set_time_factor(Real tf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_set_time_factor(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);
  {
    try {
      (arg1)->setTimeFactor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FrameTimeControllerValue.get_frame_delay

  call-seq:
    get_frame_delay -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_get_frame_delay(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);
  {
    try {
      result = (Ogre::Real)((Ogre::FrameTimeControllerValue const *)arg1)->getFrameDelay();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FrameTimeControllerValue.set_frame_delay

  call-seq:
    set_frame_delay(Real fd)

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_set_frame_delay(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);
  {
    try {
      (arg1)->setFrameDelay(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FrameTimeControllerValue.get_elapsed_time

  call-seq:
    get_elapsed_time -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_get_elapsed_time(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);
  {
    try {
      result = (Ogre::Real)((Ogre::FrameTimeControllerValue const *)arg1)->getElapsedTime();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FrameTimeControllerValue.set_elapsed_time

  call-seq:
    set_elapsed_time(Real elapsedTime)

An instance method.

*/
SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_set_elapsed_time(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);
  {
    try {
      (arg1)->setElapsedTime(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FrameTimeControllerValue(Ogre::FrameTimeControllerValue *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::TextureFrameControllerValue

  Proxy of C++ Ogre::TextureFrameControllerValue class


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


/*
  Document-method: Ogre::TextureFrameControllerValue.new

  call-seq:
    TextureFrameControllerValue.new(TextureUnitState t)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::TextureFrameControllerValue *)new Ogre::TextureFrameControllerValue(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureFrameControllerValue.get_value

  call-seq:
    get_value -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureFrameControllerValue_get_value(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TextureFrameControllerValue const *)arg1)->getValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureFrameControllerValue.set_value

  call-seq:
    set_value(Real value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextureFrameControllerValue_set_value(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);
  {
    try {
      (arg1)->setValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TextureFrameControllerValue(Ogre::TextureFrameControllerValue *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::TexCoordModifierControllerValue

  Proxy of C++ Ogre::TexCoordModifierControllerValue class


*/
swig_class SwigClassTexCoordModifierControllerValue;


/*
  Document-method: Ogre::TexCoordModifierControllerValue.new

  call-seq:
    TexCoordModifierControllerValue.new(TextureUnitState t, bool translateU=false, bool translateV=false, 
    bool scaleU=false, bool scaleV=false, 
    bool rotate=false)
    TexCoordModifierControllerValue.new(TextureUnitState t, bool translateU=false, bool translateV=false, 
    bool scaleU=false, bool scaleV=false)
    TexCoordModifierControllerValue.new(TextureUnitState t, bool translateU=false, bool translateV=false, 
    bool scaleU=false)
    TexCoordModifierControllerValue.new(TextureUnitState t, bool translateU=false, bool translateV=false)
    TexCoordModifierControllerValue.new(TextureUnitState t, bool translateU=false)
    TexCoordModifierControllerValue.new(TextureUnitState t)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::TexCoordModifierControllerValue *)new Ogre::TexCoordModifierControllerValue(arg1,arg2,arg3,arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::TexCoordModifierControllerValue *)new Ogre::TexCoordModifierControllerValue(arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::TexCoordModifierControllerValue *)new Ogre::TexCoordModifierControllerValue(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::TexCoordModifierControllerValue *)new Ogre::TexCoordModifierControllerValue(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::TexCoordModifierControllerValue *)new Ogre::TexCoordModifierControllerValue(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::TexCoordModifierControllerValue *)new Ogre::TexCoordModifierControllerValue(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::TexCoordModifierControllerValue.get_value

  call-seq:
    get_value -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TexCoordModifierControllerValue_get_value(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TexCoordModifierControllerValue const *)arg1)->getValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TexCoordModifierControllerValue.set_value

  call-seq:
    set_value(Real value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TexCoordModifierControllerValue_set_value(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);
  {
    try {
      (arg1)->setValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TexCoordModifierControllerValue(Ogre::TexCoordModifierControllerValue *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::FloatGpuParameterControllerValue

  Proxy of C++ Ogre::FloatGpuParameterControllerValue class


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


/*
  Document-method: Ogre::FloatGpuParameterControllerValue.new

  call-seq:
    FloatGpuParameterControllerValue.new(GpuProgramParametersSharedPtr params, size_t index)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::FloatGpuParameterControllerValue *)new Ogre::FloatGpuParameterControllerValue(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FloatGpuParameterControllerValue(Ogre::FloatGpuParameterControllerValue *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::FloatGpuParameterControllerValue.get_value

  call-seq:
    get_value -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_FloatGpuParameterControllerValue_get_value(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);
  {
    try {
      result = (Ogre::Real)((Ogre::FloatGpuParameterControllerValue const *)arg1)->getValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FloatGpuParameterControllerValue.set_value

  call-seq:
    set_value(Real value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_FloatGpuParameterControllerValue_set_value(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);
  {
    try {
      (arg1)->setValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PassthroughControllerFunction

  Proxy of C++ Ogre::PassthroughControllerFunction class


*/
swig_class SwigClassPassthroughControllerFunction;


/*
  Document-method: Ogre::PassthroughControllerFunction.new

  call-seq:
    PassthroughControllerFunction.new(bool deltaInput=false)
    PassthroughControllerFunction.new

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::PassthroughControllerFunction *)new Ogre::PassthroughControllerFunction(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      result = (Ogre::PassthroughControllerFunction *)new Ogre::PassthroughControllerFunction();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::PassthroughControllerFunction.calculate

  call-seq:
    calculate(Real source) -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)(arg1)->calculate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PassthroughControllerFunction(Ogre::PassthroughControllerFunction *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::AnimationControllerFunction

  Proxy of C++ Ogre::AnimationControllerFunction class


*/
swig_class SwigClassAnimationControllerFunction;


/*
  Document-method: Ogre::AnimationControllerFunction.new

  call-seq:
    AnimationControllerFunction.new(Real sequenceTime, Real timeOffset=0.0)
    AnimationControllerFunction.new(Real sequenceTime)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::AnimationControllerFunction *)new Ogre::AnimationControllerFunction(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::AnimationControllerFunction *)new Ogre::AnimationControllerFunction(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::AnimationControllerFunction.calculate

  call-seq:
    calculate(Real source) -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)(arg1)->calculate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationControllerFunction.set_time

  call-seq:
    set_time(Real timeVal)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationControllerFunction_set_time(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);
  {
    try {
      (arg1)->setTime(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationControllerFunction.set_sequence_time

  call-seq:
    set_sequence_time(Real seqVal)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AnimationControllerFunction_set_sequence_time(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);
  {
    try {
      (arg1)->setSequenceTime(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AnimationControllerFunction(Ogre::AnimationControllerFunction *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ScaleControllerFunction

  Proxy of C++ Ogre::ScaleControllerFunction class


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


/*
  Document-method: Ogre::ScaleControllerFunction.new

  call-seq:
    ScaleControllerFunction.new(Real scalefactor, bool deltaInput)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::ScaleControllerFunction *)new Ogre::ScaleControllerFunction(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScaleControllerFunction.calculate

  call-seq:
    calculate(Real source) -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)(arg1)->calculate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScaleControllerFunction(Ogre::ScaleControllerFunction *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::WaveformControllerFunction

  Proxy of C++ Ogre::WaveformControllerFunction class


*/
swig_class SwigClassWaveformControllerFunction;


/*
  Document-method: Ogre::WaveformControllerFunction.new

  call-seq:
    WaveformControllerFunction.new(WaveformType wType, Real base=0, Real frequency=1, 
    Real phase=0, Real amplitude=1, bool deltaInput=true, 
    Real dutyCycle=0.5)
    WaveformControllerFunction.new(WaveformType wType, Real base=0, Real frequency=1, 
    Real phase=0, Real amplitude=1, bool deltaInput=true)
    WaveformControllerFunction.new(WaveformType wType, Real base=0, Real frequency=1, 
    Real phase=0, Real amplitude=1)
    WaveformControllerFunction.new(WaveformType wType, Real base=0, Real frequency=1, 
    Real phase=0)
    WaveformControllerFunction.new(WaveformType wType, Real base=0, Real frequency=1)
    WaveformControllerFunction.new(WaveformType wType, Real base=0)
    WaveformControllerFunction.new(WaveformType wType)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1,arg2,arg3,arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::WaveformControllerFunction.calculate

  call-seq:
    calculate(Real source) -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real)(arg1)->calculate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_WaveformControllerFunction(Ogre::WaveformControllerFunction *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ControllerManager

  Proxy of C++ Ogre::ControllerManager class


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


/*
  Document-method: Ogre::ControllerManager.new

  call-seq:
    ControllerManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ControllerManager *)new Ogre::ControllerManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ControllerManager(Ogre::ControllerManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ControllerManager.create_controller

  call-seq:
    create_controller(ControllerValueRealPtr src, ControllerValueRealPtr dest, 
    ControllerFunctionRealPtr func) -> Ogre::Controller<(Ogre::Real)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_create_controller(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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createController((Ogre::ControllerValueRealPtr const &)*arg2,(Ogre::ControllerValueRealPtr const &)*arg3,(Ogre::ControllerFunctionRealPtr const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.create_frame_time_passthrough_controller

  call-seq:
    create_frame_time_passthrough_controller(ControllerValueRealPtr dest) -> Ogre::Controller<(Ogre::Real)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_create_frame_time_passthrough_controller(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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createFrameTimePassthroughController((Ogre::ControllerValueRealPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.clear_controllers

  call-seq:
    clear_controllers

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_clear_controllers(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);
  {
    try {
      (arg1)->clearControllers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.update_all_controllers

  call-seq:
    update_all_controllers

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_update_all_controllers(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);
  {
    try {
      (arg1)->updateAllControllers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.get_frame_time_source

  call-seq:
    get_frame_time_source -> ControllerValueRealPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_get_frame_time_source(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);
  {
    try {
      result = (Ogre::ControllerValueRealPtr *) &((Ogre::ControllerManager const *)arg1)->getFrameTimeSource();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.get_passthrough_controller_function

  call-seq:
    get_passthrough_controller_function -> ControllerFunctionRealPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_get_passthrough_controller_function(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);
  {
    try {
      result = (Ogre::ControllerFunctionRealPtr *) &((Ogre::ControllerManager const *)arg1)->getPassthroughControllerFunction();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ControllerFunctionT_float_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.create_texture_animator

  call-seq:
    create_texture_animator(TextureUnitState layer, Real sequenceTime) -> Ogre::Controller<(Ogre::Real)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_create_texture_animator(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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureAnimator(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.create_texture_uvscroller

  call-seq:
    create_texture_uvscroller(TextureUnitState layer, Real speed) -> Ogre::Controller<(Ogre::Real)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_create_texture_uvscroller(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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureUVScroller(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.create_texture_uscroller

  call-seq:
    create_texture_uscroller(TextureUnitState layer, Real uSpeed) -> Ogre::Controller<(Ogre::Real)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_create_texture_uscroller(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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureUScroller(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.create_texture_vscroller

  call-seq:
    create_texture_vscroller(TextureUnitState layer, Real vSpeed) -> Ogre::Controller<(Ogre::Real)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_create_texture_vscroller(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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureVScroller(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.create_texture_rotater

  call-seq:
    create_texture_rotater(TextureUnitState layer, Real speed) -> Ogre::Controller<(Ogre::Real)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_create_texture_rotater(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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureRotater(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.create_texture_wave_transformer

  call-seq:
    create_texture_wave_transformer(TextureUnitState layer, TextureTransformType ttype, 
    WaveformType waveType, Real base=0, Real frequency=1, 
    Real phase=0, Real amplitude=1) -> Ogre::Controller<(Ogre::Real)>
    create_texture_wave_transformer(TextureUnitState layer, TextureTransformType ttype, 
    WaveformType waveType, Real base=0, Real frequency=1, 
    Real phase=0) -> Ogre::Controller<(Ogre::Real)>
    create_texture_wave_transformer(TextureUnitState layer, TextureTransformType ttype, 
    WaveformType waveType, Real base=0, Real frequency=1) -> Ogre::Controller<(Ogre::Real)>
    create_texture_wave_transformer(TextureUnitState layer, TextureTransformType ttype, 
    WaveformType waveType, Real base=0) -> Ogre::Controller<(Ogre::Real)>
    create_texture_wave_transformer(TextureUnitState layer, TextureTransformType ttype, 
    WaveformType waveType) -> Ogre::Controller<(Ogre::Real)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_create_texture_wave_transformer__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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureWaveTransformer(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_create_texture_wave_transformer__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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureWaveTransformer(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_create_texture_wave_transformer__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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureWaveTransformer(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_create_texture_wave_transformer__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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureWaveTransformer(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_create_texture_wave_transformer__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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureWaveTransformer(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ControllerManager_create_texture_wave_transformer(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_create_texture_wave_transformer__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_create_texture_wave_transformer__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_create_texture_wave_transformer__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_create_texture_wave_transformer__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_create_texture_wave_transformer__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "ControllerManager.create_texture_wave_transformer", 
    "    Ogre::Controller< Ogre::Real > * ControllerManager.create_texture_wave_transformer(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.create_texture_wave_transformer(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.create_texture_wave_transformer(Ogre::TextureUnitState *layer, Ogre::TextureUnitState::TextureTransformType ttype, Ogre::WaveformType waveType, Ogre::Real base, Ogre::Real frequency)\n"
    "    Ogre::Controller< Ogre::Real > * ControllerManager.create_texture_wave_transformer(Ogre::TextureUnitState *layer, Ogre::TextureUnitState::TextureTransformType ttype, Ogre::WaveformType waveType, Ogre::Real base)\n"
    "    Ogre::Controller< Ogre::Real > * ControllerManager.create_texture_wave_transformer(Ogre::TextureUnitState *layer, Ogre::TextureUnitState::TextureTransformType ttype, Ogre::WaveformType waveType)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.create_gpu_program_timer_param

  call-seq:
    create_gpu_program_timer_param(GpuProgramParametersSharedPtr params, size_t paramIndex, 
    Real timeFactor=1.0) -> Ogre::Controller<(Ogre::Real)>
    create_gpu_program_timer_param(GpuProgramParametersSharedPtr params, size_t paramIndex) -> Ogre::Controller<(Ogre::Real)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_create_gpu_program_timer_param__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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createGpuProgramTimerParam(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_create_gpu_program_timer_param__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);
  {
    try {
      result = (Ogre::Controller< Ogre::Real > *)(arg1)->createGpuProgramTimerParam(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ControllerManager_create_gpu_program_timer_param(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_create_gpu_program_timer_param__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_create_gpu_program_timer_param__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ControllerManager.create_gpu_program_timer_param", 
    "    Ogre::Controller< Ogre::Real > * ControllerManager.create_gpu_program_timer_param(Ogre::GpuProgramParametersSharedPtr params, size_t paramIndex, Ogre::Real timeFactor)\n"
    "    Ogre::Controller< Ogre::Real > * ControllerManager.create_gpu_program_timer_param(Ogre::GpuProgramParametersSharedPtr params, size_t paramIndex)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.destroy_controller

  call-seq:
    destroy_controller(Ogre::Controller<(Ogre::Real)> controller)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_destroy_controller(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);
  {
    try {
      (arg1)->destroyController(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.get_time_factor

  call-seq:
    get_time_factor -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_get_time_factor(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ControllerManager const *)arg1)->getTimeFactor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.set_time_factor

  call-seq:
    set_time_factor(Real tf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_set_time_factor(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);
  {
    try {
      (arg1)->setTimeFactor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.get_frame_delay

  call-seq:
    get_frame_delay -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_get_frame_delay(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ControllerManager const *)arg1)->getFrameDelay();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.set_frame_delay

  call-seq:
    set_frame_delay(Real fd)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_set_frame_delay(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);
  {
    try {
      (arg1)->setFrameDelay(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.get_elapsed_time

  call-seq:
    get_elapsed_time -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_get_elapsed_time(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ControllerManager const *)arg1)->getElapsedTime();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.set_elapsed_time

  call-seq:
    set_elapsed_time(Real elapsedTime)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_set_elapsed_time(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);
  {
    try {
      (arg1)->setElapsedTime(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.get_singleton

  call-seq:
    get_singleton -> ControllerManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::ControllerManager *) &Ogre::ControllerManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ControllerManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> ControllerManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ControllerManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::ControllerManager *)Ogre::ControllerManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Polygon

  Proxy of C++ Ogre::Polygon class


*/
swig_class SwigClassPolygon;


/*
  Document-method: Ogre::Polygon.new

  call-seq:
    Polygon.new
    Polygon.new(Polygon cpy)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Polygon *)new Ogre::Polygon();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_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);
  {
    try {
      result = (Ogre::Polygon *)new Ogre::Polygon((Ogre::Polygon const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::Polygon.insert_vertex

  call-seq:
    insert_vertex(Vector3 vdata, size_t vertexIndex)
    insert_vertex(Vector3 vdata)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Polygon_insert_vertex__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);
  {
    try {
      (arg1)->insertVertex((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Polygon_insert_vertex__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);
  {
    try {
      (arg1)->insertVertex((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Polygon_insert_vertex(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_insert_vertex__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_insert_vertex__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Polygon.insert_vertex", 
    "    void Polygon.insert_vertex(Ogre::Vector3 const &vdata, size_t vertexIndex)\n"
    "    void Polygon.insert_vertex(Ogre::Vector3 const &vdata)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Polygon.get_vertex

  call-seq:
    get_vertex(size_t vertex) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Polygon_get_vertex(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Polygon const *)arg1)->getVertex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Polygon.set_vertex

  call-seq:
    set_vertex(Vector3 vdata, size_t vertexIndex)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Polygon_set_vertex(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);
  {
    try {
      (arg1)->setVertex((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Polygon.remove_duplicates

  call-seq:
    remove_duplicates

An instance method.

*/
SWIGINTERN VALUE
_wrap_Polygon_remove_duplicates(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);
  {
    try {
      (arg1)->removeDuplicates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Polygon.get_vertex_count

  call-seq:
    get_vertex_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Polygon_get_vertex_count(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);
  {
    try {
      result = ((Ogre::Polygon const *)arg1)->getVertexCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Polygon.get_normal

  call-seq:
    get_normal -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Polygon_get_normal(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Polygon const *)arg1)->getNormal();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Polygon.delete_vertex

  call-seq:
    delete_vertex(size_t vertex)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Polygon_delete_vertex(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);
  {
    try {
      (arg1)->deleteVertex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Polygon.is_point_inside

  call-seq:
    is_point_inside(Vector3 point) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Polygon_is_point_inside(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);
  {
    try {
      result = (bool)((Ogre::Polygon const *)arg1)->isPointInside((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Polygon.store_edges

  call-seq:
    store_edges(EdgeMap edgeMap)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Polygon_store_edges(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);
  {
    try {
      ((Ogre::Polygon const *)arg1)->storeEdges(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Polygon.reset

  call-seq:
    reset

An instance method.

*/
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);
  {
    try {
      (arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::Polygon const *)arg1)->operator ==((Ogre::Polygon const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ConvexBody

  Proxy of C++ Ogre::ConvexBody class


*/
swig_class SwigClassConvexBody;


/*
  Document-method: Ogre::ConvexBody.new

  call-seq:
    ConvexBody.new
    ConvexBody.new(ConvexBody cpy)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ConvexBody *)new Ogre::ConvexBody();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_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);
  {
    try {
      result = (Ogre::ConvexBody *)new Ogre::ConvexBody((Ogre::ConvexBody const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::ConvexBody.define

  call-seq:
    define(Frustum frustum)
    define(AxisAlignedBox aab)

An instance method.

*/
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);
  {
    try {
      (arg1)->define((Ogre::Frustum const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->define((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::ConvexBody.clip

  call-seq:
    clip(Frustum frustum)
    clip(AxisAlignedBox aab)
    clip(ConvexBody body)
    clip(Plane pl, bool keepNegative=true)
    clip(Plane pl)

An instance method.

*/
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);
  {
    try {
      (arg1)->clip((Ogre::Frustum const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->clip((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->clip((Ogre::ConvexBody const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->clip((Ogre::Plane const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->clip((Ogre::Plane const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::ConvexBody.extend

  call-seq:
    extend(Vector3 pt)

An instance method.

*/
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);
  {
    try {
      (arg1)->extend((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody.reset

  call-seq:
    reset

An instance method.

*/
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);
  {
    try {
      (arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody.get_polygon_count

  call-seq:
    get_polygon_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConvexBody_get_polygon_count(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);
  {
    try {
      result = ((Ogre::ConvexBody const *)arg1)->getPolygonCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody.get_vertex_count

  call-seq:
    get_vertex_count(size_t poly) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConvexBody_get_vertex_count(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);
  {
    try {
      result = ((Ogre::ConvexBody const *)arg1)->getVertexCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody.get_polygon

  call-seq:
    get_polygon(size_t poly) -> Polygon

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConvexBody_get_polygon(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);
  {
    try {
      result = (Ogre::Polygon *) &((Ogre::ConvexBody const *)arg1)->getPolygon(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Polygon, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody.get_vertex

  call-seq:
    get_vertex(size_t poly, size_t vertex) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConvexBody_get_vertex(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::ConvexBody const *)arg1)->getVertex(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody.get_normal

  call-seq:
    get_normal(size_t poly) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConvexBody_get_normal(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);
  {
    try {
      result = (Ogre::Vector3 *) &(arg1)->getNormal(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody.get_aabb

  call-seq:
    get_aabb -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConvexBody_get_aabb(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);
  {
    try {
      result = ((Ogre::ConvexBody const *)arg1)->getAABB();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::AxisAlignedBox(static_cast< const Ogre::AxisAlignedBox& >(result))), SWIGTYPE_p_Ogre__AxisAlignedBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody.has_closed_hull

  call-seq:
    has_closed_hull -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConvexBody_has_closed_hull(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);
  {
    try {
      result = (bool)((Ogre::ConvexBody const *)arg1)->hasClosedHull();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody.merge_polygons

  call-seq:
    merge_polygons

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConvexBody_merge_polygons(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);
  {
    try {
      (arg1)->mergePolygons();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (bool)((Ogre::ConvexBody const *)arg1)->operator ==((Ogre::ConvexBody const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody.log_info

  call-seq:
    log_info

An instance method.

*/
SWIGINTERN VALUE
_wrap_ConvexBody_log_info(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);
  {
    try {
      ((Ogre::ConvexBody const *)arg1)->logInfo();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody._initialise_pool

  call-seq:
    _initialise_pool

A class method.

*/
SWIGINTERN VALUE
_wrap_ConvexBody__initialise_pool(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      Ogre::ConvexBody::_initialisePool();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody._destroy_pool

  call-seq:
    _destroy_pool

A class method.

*/
SWIGINTERN VALUE
_wrap_ConvexBody__destroy_pool(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      Ogre::ConvexBody::_destroyPool();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::CustomCompositionPass

  Proxy of C++ Ogre::CustomCompositionPass class


*/
swig_class SwigClassCustomCompositionPass;


/*
  Document-method: Ogre::CustomCompositionPass.create_operation

  call-seq:
    create_operation(CompositorInstance instance, CompositionPass pass) -> RenderSystemOperation

An instance method.

*/
SWIGINTERN VALUE
_wrap_CustomCompositionPass_create_operation(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);
  {
    try {
      result = (Ogre::CompositorInstance::RenderSystemOperation *)(arg1)->createOperation(arg2,(Ogre::CompositionPass const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance__RenderSystemOperation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ImageCodec < Ogre::Ogre::Codec

  Proxy of C++ Ogre::ImageCodec class


*/
swig_class SwigClassImageCodec;

SWIGINTERN void
free_Ogre_ImageCodec(Ogre::ImageCodec *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ImageCodec.get_data_type

  call-seq:
    get_data_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ImageCodec_get_data_type(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);
  {
    try {
      result = ((Ogre::ImageCodec const *)arg1)->getDataType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DDSCodec < Ogre::Ogre::ImageCodec

  Proxy of C++ Ogre::DDSCodec class


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


/*
  Document-method: Ogre::DDSCodec.new

  call-seq:
    DDSCodec.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::DDSCodec *)new Ogre::DDSCodec();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DDSCodec(Ogre::DDSCodec *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DDSCodec.code

  call-seq:
    code(MemoryDataStreamPtr input, CodecDataPtr pData) -> DataStreamPtr

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::DDSCodec const *)arg1)->code(*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DDSCodec.code_to_file

  call-seq:
    code_to_file(MemoryDataStreamPtr input, String outFileName, CodecDataPtr pData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DDSCodec_code_to_file(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);
  {
    try {
      ((Ogre::DDSCodec const *)arg1)->codeToFile(*arg2,(Ogre::String const &)*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::DDSCodec.decode

  call-seq:
    decode(DataStreamPtr input) -> DecodeResult

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::DDSCodec const *)arg1)->decode(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::DDSCodec.magic_number_to_file_ext

  call-seq:
    magic_number_to_file_ext(char magicNumberPtr, size_t maxbytes) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_DDSCodec_magic_number_to_file_ext(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);
  {
    try {
      result = ((Ogre::DDSCodec const *)arg1)->magicNumberToFileExt((char const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::DDSCodec.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_DDSCodec_get_type(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);
  {
    try {
      result = ((Ogre::DDSCodec const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DDSCodec.startup

  call-seq:
    startup

A class method.

*/
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;
  }
  {
    try {
      Ogre::DDSCodec::startup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DDSCodec.shutdown

  call-seq:
    shutdown

A class method.

*/
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;
  }
  {
    try {
      Ogre::DDSCodec::shutdown();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RenderToVertexBuffer

  Proxy of C++ Ogre::RenderToVertexBuffer class


*/
swig_class SwigClassRenderToVertexBuffer;

SWIGINTERN void
free_Ogre_RenderToVertexBuffer(Ogre::RenderToVertexBuffer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderToVertexBuffer.get_vertex_declaration

  call-seq:
    get_vertex_declaration -> VertexDeclaration

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_get_vertex_declaration(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);
  {
    try {
      result = (Ogre::VertexDeclaration *)(arg1)->getVertexDeclaration();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.get_max_vertex_count

  call-seq:
    get_max_vertex_count -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_get_max_vertex_count(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);
  {
    try {
      result = (unsigned int)((Ogre::RenderToVertexBuffer const *)arg1)->getMaxVertexCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.set_max_vertex_count

  call-seq:
    set_max_vertex_count(unsigned int maxVertexCount)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_set_max_vertex_count(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);
  {
    try {
      (arg1)->setMaxVertexCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.get_operation_type

  call-seq:
    get_operation_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_get_operation_type(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);
  {
    try {
      result = (Ogre::RenderOperation::OperationType)((Ogre::RenderToVertexBuffer const *)arg1)->getOperationType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.set_operation_type

  call-seq:
    set_operation_type(OperationType operationType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_set_operation_type(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);
  {
    try {
      (arg1)->setOperationType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.set_resets_every_update

  call-seq:
    set_resets_every_update(bool resetsEveryUpdate)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_set_resets_every_update(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);
  {
    try {
      (arg1)->setResetsEveryUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.get_resets_every_update

  call-seq:
    get_resets_every_update -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_get_resets_every_update(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);
  {
    try {
      result = (bool)((Ogre::RenderToVertexBuffer const *)arg1)->getResetsEveryUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.get_render_operation

  call-seq:
    get_render_operation(RenderOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_get_render_operation(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);
  {
    try {
      (arg1)->getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.update

  call-seq:
    update(SceneManager sceneMgr)

An instance method.

*/
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);
  {
    try {
      (arg1)->update(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.reset

  call-seq:
    reset

An instance method.

*/
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);
  {
    try {
      (arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.set_source_renderable

  call-seq:
    set_source_renderable(Renderable source)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_set_source_renderable(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);
  {
    try {
      (arg1)->setSourceRenderable(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.get_source_renderable

  call-seq:
    get_source_renderable -> Renderable

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_get_source_renderable(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);
  {
    try {
      result = (Ogre::Renderable *)((Ogre::RenderToVertexBuffer const *)arg1)->getSourceRenderable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.get_render_to_buffer_material

  call-seq:
    get_render_to_buffer_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_get_render_to_buffer_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &(arg1)->getRenderToBufferMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderToVertexBuffer.set_render_to_buffer_material_name

  call-seq:
    set_render_to_buffer_material_name(String materialName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_set_render_to_buffer_material_name(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;
  }
  {
    try {
      (arg1)->setRenderToBufferMaterialName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-class: Ogre::HardwareBufferLicensee

  Proxy of C++ Ogre::HardwareBufferLicensee class


*/
swig_class SwigClassHardwareBufferLicensee;

SWIGINTERN void
free_Ogre_HardwareBufferLicensee(Ogre::HardwareBufferLicensee *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::HardwareBufferLicensee.license_expired

  call-seq:
    license_expired(HardwareBuffer buffer)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferLicensee_license_expired(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);
  {
    try {
      (arg1)->licenseExpired(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::TempBlendedBufferInfo < Ogre::Ogre::HardwareBufferLicensee

  Proxy of C++ Ogre::TempBlendedBufferInfo class


*/
swig_class SwigClassTempBlendedBufferInfo;

SWIGINTERN void
free_Ogre_TempBlendedBufferInfo(Ogre::TempBlendedBufferInfo *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::TempBlendedBufferInfo.extract_from

  call-seq:
    extract_from(VertexData sourceData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_extract_from(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);
  {
    try {
      (arg1)->extractFrom((Ogre::VertexData const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TempBlendedBufferInfo.checkout_temp_copies

  call-seq:
    checkout_temp_copies(bool positions=true, bool normals=true)
    checkout_temp_copies(bool positions=true)
    checkout_temp_copies

An instance method.

*/
SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_checkout_temp_copies__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);
  {
    try {
      (arg1)->checkoutTempCopies(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_checkout_temp_copies__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);
  {
    try {
      (arg1)->checkoutTempCopies(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_checkout_temp_copies__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);
  {
    try {
      (arg1)->checkoutTempCopies();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TempBlendedBufferInfo_checkout_temp_copies(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_checkout_temp_copies__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_checkout_temp_copies__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_checkout_temp_copies__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TempBlendedBufferInfo.checkout_temp_copies", 
    "    void TempBlendedBufferInfo.checkout_temp_copies(bool positions, bool normals)\n"
    "    void TempBlendedBufferInfo.checkout_temp_copies(bool positions)\n"
    "    void TempBlendedBufferInfo.checkout_temp_copies()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TempBlendedBufferInfo.bind_temp_copies

  call-seq:
    bind_temp_copies(VertexData targetData, bool suppressHardwareUpload)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_bind_temp_copies(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);
  {
    try {
      (arg1)->bindTempCopies(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TempBlendedBufferInfo.license_expired

  call-seq:
    license_expired(HardwareBuffer buffer)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_license_expired(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);
  {
    try {
      (arg1)->licenseExpired(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TempBlendedBufferInfo.buffers_checked_out

  call-seq:
    buffers_checked_out(bool positions=true, bool normals=true) -> bool
    buffers_checked_out(bool positions=true) -> bool
    buffers_checked_out -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_buffers_checked_out__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);
  {
    try {
      result = (bool)((Ogre::TempBlendedBufferInfo const *)arg1)->buffersCheckedOut(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_buffers_checked_out__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);
  {
    try {
      result = (bool)((Ogre::TempBlendedBufferInfo const *)arg1)->buffersCheckedOut(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_buffers_checked_out__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);
  {
    try {
      result = (bool)((Ogre::TempBlendedBufferInfo const *)arg1)->buffersCheckedOut();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TempBlendedBufferInfo_buffers_checked_out(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_buffers_checked_out__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_buffers_checked_out__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_buffers_checked_out__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TempBlendedBufferInfo.buffers_checked_out", 
    "    bool TempBlendedBufferInfo.buffers_checked_out(bool positions, bool normals)\n"
    "    bool TempBlendedBufferInfo.buffers_checked_out(bool positions)\n"
    "    bool TempBlendedBufferInfo.buffers_checked_out()\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;
  }
  


/*
  Document-method: Ogre::TempBlendedBufferInfo.new

  call-seq:
    TempBlendedBufferInfo.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TempBlendedBufferInfo *)new Ogre::TempBlendedBufferInfo();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::HardwareBufferManagerBase

  Proxy of C++ Ogre::HardwareBufferManagerBase class


*/
swig_class SwigClassHardwareBufferManagerBase;


/*
  Document-method: Ogre::BufferLicenseType.BLT_MANUAL_RELEASE

  call-seq:
    BLT_MANUAL_RELEASE -> int

A class method.

*/

/*
  Document-method: Ogre::BufferLicenseType.BLT_AUTOMATIC_RELEASE

  call-seq:
    BLT_AUTOMATIC_RELEASE -> int

A class method.

*/
SWIGINTERN void
free_Ogre_HardwareBufferManagerBase(Ogre::HardwareBufferManagerBase *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::HardwareBufferManagerBase.create_vertex_buffer

  call-seq:
    create_vertex_buffer(size_t vertexSize, size_t numVerts, Usage usage, bool useShadowBuffer=false) -> HardwareVertexBufferSharedPtr
    create_vertex_buffer(size_t vertexSize, size_t numVerts, Usage usage) -> HardwareVertexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_create_vertex_buffer__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);
  {
    try {
      result = (arg1)->createVertexBuffer(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_create_vertex_buffer__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);
  {
    try {
      result = (arg1)->createVertexBuffer(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_create_vertex_buffer(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_create_vertex_buffer__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_create_vertex_buffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBufferManagerBase.create_vertex_buffer", 
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManagerBase.create_vertex_buffer(size_t vertexSize, size_t numVerts, Ogre::HardwareBuffer::Usage usage, bool useShadowBuffer)\n"
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManagerBase.create_vertex_buffer(size_t vertexSize, size_t numVerts, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase.create_index_buffer

  call-seq:
    create_index_buffer(IndexType itype, size_t numIndexes, Usage usage, bool useShadowBuffer=false) -> HardwareIndexBufferSharedPtr
    create_index_buffer(IndexType itype, size_t numIndexes, Usage usage) -> HardwareIndexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_create_index_buffer__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);
  {
    try {
      result = (arg1)->createIndexBuffer(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_create_index_buffer__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);
  {
    try {
      result = (arg1)->createIndexBuffer(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_create_index_buffer(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_create_index_buffer__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_create_index_buffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBufferManagerBase.create_index_buffer", 
    "    Ogre::HardwareIndexBufferSharedPtr HardwareBufferManagerBase.create_index_buffer(Ogre::HardwareIndexBuffer::IndexType itype, size_t numIndexes, Ogre::HardwareBuffer::Usage usage, bool useShadowBuffer)\n"
    "    Ogre::HardwareIndexBufferSharedPtr HardwareBufferManagerBase.create_index_buffer(Ogre::HardwareIndexBuffer::IndexType itype, size_t numIndexes, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase.create_render_to_vertex_buffer

  call-seq:
    create_render_to_vertex_buffer -> RenderToVertexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_create_render_to_vertex_buffer(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);
  {
    try {
      result = (arg1)->createRenderToVertexBuffer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::RenderToVertexBufferSharedPtr(static_cast< const Ogre::RenderToVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase.create_vertex_declaration

  call-seq:
    create_vertex_declaration -> VertexDeclaration

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_create_vertex_declaration(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);
  {
    try {
      result = (Ogre::VertexDeclaration *)(arg1)->createVertexDeclaration();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase.destroy_vertex_declaration

  call-seq:
    destroy_vertex_declaration(VertexDeclaration decl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_destroy_vertex_declaration(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);
  {
    try {
      (arg1)->destroyVertexDeclaration(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase.create_vertex_buffer_binding

  call-seq:
    create_vertex_buffer_binding -> VertexBufferBinding

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_create_vertex_buffer_binding(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);
  {
    try {
      result = (Ogre::VertexBufferBinding *)(arg1)->createVertexBufferBinding();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexBufferBinding, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase.destroy_vertex_buffer_binding

  call-seq:
    destroy_vertex_buffer_binding(VertexBufferBinding binding)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_destroy_vertex_buffer_binding(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);
  {
    try {
      (arg1)->destroyVertexBufferBinding(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase.register_vertex_buffer_source_and_copy

  call-seq:
    register_vertex_buffer_source_and_copy(HardwareVertexBufferSharedPtr sourceBuffer, HardwareVertexBufferSharedPtr copy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_register_vertex_buffer_source_and_copy(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);
  {
    try {
      (arg1)->registerVertexBufferSourceAndCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2,(Ogre::HardwareVertexBufferSharedPtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase.allocate_vertex_buffer_copy

  call-seq:
    allocate_vertex_buffer_copy(HardwareVertexBufferSharedPtr sourceBuffer, BufferLicenseType licenseType, 
    HardwareBufferLicensee licensee, 
    bool copyData=false) -> HardwareVertexBufferSharedPtr
    allocate_vertex_buffer_copy(HardwareVertexBufferSharedPtr sourceBuffer, BufferLicenseType licenseType, 
    HardwareBufferLicensee licensee) -> HardwareVertexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_allocate_vertex_buffer_copy__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);
  {
    try {
      result = (arg1)->allocateVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_allocate_vertex_buffer_copy__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);
  {
    try {
      result = (arg1)->allocateVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_allocate_vertex_buffer_copy(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_allocate_vertex_buffer_copy__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_allocate_vertex_buffer_copy__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBufferManagerBase.allocate_vertex_buffer_copy", 
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManagerBase.allocate_vertex_buffer_copy(Ogre::HardwareVertexBufferSharedPtr const &sourceBuffer, Ogre::HardwareBufferManagerBase::BufferLicenseType licenseType, Ogre::HardwareBufferLicensee *licensee, bool copyData)\n"
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManagerBase.allocate_vertex_buffer_copy(Ogre::HardwareVertexBufferSharedPtr const &sourceBuffer, Ogre::HardwareBufferManagerBase::BufferLicenseType licenseType, Ogre::HardwareBufferLicensee *licensee)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase.release_vertex_buffer_copy

  call-seq:
    release_vertex_buffer_copy(HardwareVertexBufferSharedPtr bufferCopy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_release_vertex_buffer_copy(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);
  {
    try {
      (arg1)->releaseVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase.touch_vertex_buffer_copy

  call-seq:
    touch_vertex_buffer_copy(HardwareVertexBufferSharedPtr bufferCopy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_touch_vertex_buffer_copy(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);
  {
    try {
      (arg1)->touchVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase._free_unused_buffer_copies

  call-seq:
    _free_unused_buffer_copies

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__free_unused_buffer_copies(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);
  {
    try {
      (arg1)->_freeUnusedBufferCopies();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase._release_buffer_copies

  call-seq:
    _release_buffer_copies(bool forceFreeUnused=false)
    _release_buffer_copies

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__release_buffer_copies__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);
  {
    try {
      (arg1)->_releaseBufferCopies(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__release_buffer_copies__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);
  {
    try {
      (arg1)->_releaseBufferCopies();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManagerBase__release_buffer_copies(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__release_buffer_copies__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__release_buffer_copies__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "HardwareBufferManagerBase._release_buffer_copies", 
    "    void HardwareBufferManagerBase._release_buffer_copies(bool forceFreeUnused)\n"
    "    void HardwareBufferManagerBase._release_buffer_copies()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase._force_release_buffer_copies

  call-seq:
    _force_release_buffer_copies(HardwareVertexBufferSharedPtr sourceBuffer)
    _force_release_buffer_copies(HardwareVertexBuffer sourceBuffer)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__force_release_buffer_copies__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);
  {
    try {
      (arg1)->_forceReleaseBufferCopies((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__force_release_buffer_copies__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);
  {
    try {
      (arg1)->_forceReleaseBufferCopies(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManagerBase__force_release_buffer_copies(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__force_release_buffer_copies__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__force_release_buffer_copies__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "HardwareBufferManagerBase._force_release_buffer_copies", 
    "    void HardwareBufferManagerBase._force_release_buffer_copies(Ogre::HardwareVertexBufferSharedPtr const &sourceBuffer)\n"
    "    void HardwareBufferManagerBase._force_release_buffer_copies(Ogre::HardwareVertexBuffer *sourceBuffer)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase._notify_vertex_buffer_destroyed

  call-seq:
    _notify_vertex_buffer_destroyed(HardwareVertexBuffer buf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__notify_vertex_buffer_destroyed(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);
  {
    try {
      (arg1)->_notifyVertexBufferDestroyed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManagerBase._notify_index_buffer_destroyed

  call-seq:
    _notify_index_buffer_destroyed(HardwareIndexBuffer buf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__notify_index_buffer_destroyed(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);
  {
    try {
      (arg1)->_notifyIndexBufferDestroyed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::HardwareBufferManager < Ogre::Ogre::HardwareBufferManagerBase

  Proxy of C++ Ogre::HardwareBufferManager class


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


/*
  Document-method: Ogre::HardwareBufferManager.new

  call-seq:
    HardwareBufferManager.new(HardwareBufferManagerBase imp)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::HardwareBufferManager *)new Ogre::HardwareBufferManager(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_HardwareBufferManager(Ogre::HardwareBufferManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::HardwareBufferManager.create_vertex_buffer

  call-seq:
    create_vertex_buffer(size_t vertexSize, size_t numVerts, Usage usage, bool useShadowBuffer=false) -> HardwareVertexBufferSharedPtr
    create_vertex_buffer(size_t vertexSize, size_t numVerts, Usage usage) -> HardwareVertexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_create_vertex_buffer__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);
  {
    try {
      result = (arg1)->createVertexBuffer(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_create_vertex_buffer__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);
  {
    try {
      result = (arg1)->createVertexBuffer(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_create_vertex_buffer(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_create_vertex_buffer__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_create_vertex_buffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBufferManager.create_vertex_buffer", 
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManager.create_vertex_buffer(size_t vertexSize, size_t numVerts, Ogre::HardwareBuffer::Usage usage, bool useShadowBuffer)\n"
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManager.create_vertex_buffer(size_t vertexSize, size_t numVerts, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager.create_index_buffer

  call-seq:
    create_index_buffer(IndexType itype, size_t numIndexes, Usage usage, bool useShadowBuffer=false) -> HardwareIndexBufferSharedPtr
    create_index_buffer(IndexType itype, size_t numIndexes, Usage usage) -> HardwareIndexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_create_index_buffer__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);
  {
    try {
      result = (arg1)->createIndexBuffer(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_create_index_buffer__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);
  {
    try {
      result = (arg1)->createIndexBuffer(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_create_index_buffer(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_create_index_buffer__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_create_index_buffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBufferManager.create_index_buffer", 
    "    Ogre::HardwareIndexBufferSharedPtr HardwareBufferManager.create_index_buffer(Ogre::HardwareIndexBuffer::IndexType itype, size_t numIndexes, Ogre::HardwareBuffer::Usage usage, bool useShadowBuffer)\n"
    "    Ogre::HardwareIndexBufferSharedPtr HardwareBufferManager.create_index_buffer(Ogre::HardwareIndexBuffer::IndexType itype, size_t numIndexes, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager.create_render_to_vertex_buffer

  call-seq:
    create_render_to_vertex_buffer -> RenderToVertexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_create_render_to_vertex_buffer(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);
  {
    try {
      result = (arg1)->createRenderToVertexBuffer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::RenderToVertexBufferSharedPtr(static_cast< const Ogre::RenderToVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager.create_vertex_declaration

  call-seq:
    create_vertex_declaration -> VertexDeclaration

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_create_vertex_declaration(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);
  {
    try {
      result = (Ogre::VertexDeclaration *)(arg1)->createVertexDeclaration();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager.destroy_vertex_declaration

  call-seq:
    destroy_vertex_declaration(VertexDeclaration decl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_destroy_vertex_declaration(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);
  {
    try {
      (arg1)->destroyVertexDeclaration(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager.create_vertex_buffer_binding

  call-seq:
    create_vertex_buffer_binding -> VertexBufferBinding

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_create_vertex_buffer_binding(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);
  {
    try {
      result = (Ogre::VertexBufferBinding *)(arg1)->createVertexBufferBinding();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexBufferBinding, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager.destroy_vertex_buffer_binding

  call-seq:
    destroy_vertex_buffer_binding(VertexBufferBinding binding)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_destroy_vertex_buffer_binding(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);
  {
    try {
      (arg1)->destroyVertexBufferBinding(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager.register_vertex_buffer_source_and_copy

  call-seq:
    register_vertex_buffer_source_and_copy(HardwareVertexBufferSharedPtr sourceBuffer, HardwareVertexBufferSharedPtr copy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_register_vertex_buffer_source_and_copy(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);
  {
    try {
      (arg1)->registerVertexBufferSourceAndCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2,(Ogre::HardwareVertexBufferSharedPtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager.allocate_vertex_buffer_copy

  call-seq:
    allocate_vertex_buffer_copy(HardwareVertexBufferSharedPtr sourceBuffer, BufferLicenseType licenseType, 
    HardwareBufferLicensee licensee, 
    bool copyData=false) -> HardwareVertexBufferSharedPtr
    allocate_vertex_buffer_copy(HardwareVertexBufferSharedPtr sourceBuffer, BufferLicenseType licenseType, 
    HardwareBufferLicensee licensee) -> HardwareVertexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_allocate_vertex_buffer_copy__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);
  {
    try {
      result = (arg1)->allocateVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_allocate_vertex_buffer_copy__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);
  {
    try {
      result = (arg1)->allocateVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_allocate_vertex_buffer_copy(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_allocate_vertex_buffer_copy__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_allocate_vertex_buffer_copy__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBufferManager.allocate_vertex_buffer_copy", 
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManager.allocate_vertex_buffer_copy(Ogre::HardwareVertexBufferSharedPtr const &sourceBuffer, Ogre::HardwareBufferManagerBase::BufferLicenseType licenseType, Ogre::HardwareBufferLicensee *licensee, bool copyData)\n"
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManager.allocate_vertex_buffer_copy(Ogre::HardwareVertexBufferSharedPtr const &sourceBuffer, Ogre::HardwareBufferManagerBase::BufferLicenseType licenseType, Ogre::HardwareBufferLicensee *licensee)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager.release_vertex_buffer_copy

  call-seq:
    release_vertex_buffer_copy(HardwareVertexBufferSharedPtr bufferCopy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_release_vertex_buffer_copy(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);
  {
    try {
      (arg1)->releaseVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager.touch_vertex_buffer_copy

  call-seq:
    touch_vertex_buffer_copy(HardwareVertexBufferSharedPtr bufferCopy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_touch_vertex_buffer_copy(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);
  {
    try {
      (arg1)->touchVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager._free_unused_buffer_copies

  call-seq:
    _free_unused_buffer_copies

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager__free_unused_buffer_copies(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);
  {
    try {
      (arg1)->_freeUnusedBufferCopies();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager._release_buffer_copies

  call-seq:
    _release_buffer_copies(bool forceFreeUnused=false)
    _release_buffer_copies

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager__release_buffer_copies__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);
  {
    try {
      (arg1)->_releaseBufferCopies(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager__release_buffer_copies__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);
  {
    try {
      (arg1)->_releaseBufferCopies();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManager__release_buffer_copies(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__release_buffer_copies__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__release_buffer_copies__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "HardwareBufferManager._release_buffer_copies", 
    "    void HardwareBufferManager._release_buffer_copies(bool forceFreeUnused)\n"
    "    void HardwareBufferManager._release_buffer_copies()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager._force_release_buffer_copies

  call-seq:
    _force_release_buffer_copies(HardwareVertexBufferSharedPtr sourceBuffer)
    _force_release_buffer_copies(HardwareVertexBuffer sourceBuffer)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager__force_release_buffer_copies__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);
  {
    try {
      (arg1)->_forceReleaseBufferCopies((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager__force_release_buffer_copies__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);
  {
    try {
      (arg1)->_forceReleaseBufferCopies(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManager__force_release_buffer_copies(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__force_release_buffer_copies__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__force_release_buffer_copies__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "HardwareBufferManager._force_release_buffer_copies", 
    "    void HardwareBufferManager._force_release_buffer_copies(Ogre::HardwareVertexBufferSharedPtr const &sourceBuffer)\n"
    "    void HardwareBufferManager._force_release_buffer_copies(Ogre::HardwareVertexBuffer *sourceBuffer)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager._notify_vertex_buffer_destroyed

  call-seq:
    _notify_vertex_buffer_destroyed(HardwareVertexBuffer buf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager__notify_vertex_buffer_destroyed(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);
  {
    try {
      (arg1)->_notifyVertexBufferDestroyed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager._notify_index_buffer_destroyed

  call-seq:
    _notify_index_buffer_destroyed(HardwareIndexBuffer buf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager__notify_index_buffer_destroyed(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);
  {
    try {
      (arg1)->_notifyIndexBufferDestroyed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager.get_singleton

  call-seq:
    get_singleton -> HardwareBufferManager

A class method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::HardwareBufferManager *) &Ogre::HardwareBufferManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareBufferManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareBufferManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> HardwareBufferManager

A class method.

*/
SWIGINTERN VALUE
_wrap_HardwareBufferManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::HardwareBufferManager *)Ogre::HardwareBufferManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareBufferManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DefaultHardwareVertexBuffer < Ogre::Ogre::HardwareVertexBuffer

  Proxy of C++ Ogre::DefaultHardwareVertexBuffer class


*/
swig_class SwigClassDefaultHardwareVertexBuffer;


/*
  Document-method: Ogre::DefaultHardwareVertexBuffer.new

  call-seq:
    DefaultHardwareVertexBuffer.new(size_t vertexSize, size_t numVertices, Usage usage)
    DefaultHardwareVertexBuffer.new(HardwareBufferManagerBase mgr, size_t vertexSize, size_t numVertices, 
    Usage usage)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::DefaultHardwareVertexBuffer *)new Ogre::DefaultHardwareVertexBuffer(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::DefaultHardwareVertexBuffer *)new Ogre::DefaultHardwareVertexBuffer(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::DefaultHardwareVertexBuffer.read_data

  call-seq:
    read_data(size_t offset, size_t length, void pDest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultHardwareVertexBuffer_read_data(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] )); 
  }
  {
    try {
      (arg1)->readData(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultHardwareVertexBuffer.write_data

  call-seq:
    write_data(size_t offset, size_t length, void pSource, bool discardWholeBuffer=false)
    write_data(size_t offset, size_t length, void pSource)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultHardwareVertexBuffer_write_data__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);
  {
    try {
      (arg1)->writeData(arg2,arg3,(void const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareVertexBuffer_write_data__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] )); 
  }
  {
    try {
      (arg1)->writeData(arg2,arg3,(void const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DefaultHardwareVertexBuffer_write_data(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_write_data__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_write_data__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "DefaultHardwareVertexBuffer.write_data", 
    "    void DefaultHardwareVertexBuffer.write_data(size_t offset, size_t length, void const *pSource, bool discardWholeBuffer)\n"
    "    void DefaultHardwareVertexBuffer.write_data(size_t offset, size_t length, void const *pSource)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::DefaultHardwareVertexBuffer.lock

  call-seq:
    lock(size_t offset, size_t length, LockOptions options) -> void

An instance method.

*/
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);
  {
    try {
      result = (void *)(arg1)->lock(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultHardwareVertexBuffer.unlock

  call-seq:
    unlock

An instance method.

*/
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);
  {
    try {
      (arg1)->unlock();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DefaultHardwareIndexBuffer < Ogre::Ogre::HardwareIndexBuffer

  Proxy of C++ Ogre::DefaultHardwareIndexBuffer class


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


/*
  Document-method: Ogre::DefaultHardwareIndexBuffer.new

  call-seq:
    DefaultHardwareIndexBuffer.new(IndexType idxType, size_t numIndexes, Usage usage)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::DefaultHardwareIndexBuffer *)new Ogre::DefaultHardwareIndexBuffer(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultHardwareIndexBuffer(Ogre::DefaultHardwareIndexBuffer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DefaultHardwareIndexBuffer.read_data

  call-seq:
    read_data(size_t offset, size_t length, void pDest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultHardwareIndexBuffer_read_data(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] )); 
  }
  {
    try {
      (arg1)->readData(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultHardwareIndexBuffer.write_data

  call-seq:
    write_data(size_t offset, size_t length, void pSource, bool discardWholeBuffer=false)
    write_data(size_t offset, size_t length, void pSource)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultHardwareIndexBuffer_write_data__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);
  {
    try {
      (arg1)->writeData(arg2,arg3,(void const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareIndexBuffer_write_data__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] )); 
  }
  {
    try {
      (arg1)->writeData(arg2,arg3,(void const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DefaultHardwareIndexBuffer_write_data(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_write_data__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_write_data__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "DefaultHardwareIndexBuffer.write_data", 
    "    void DefaultHardwareIndexBuffer.write_data(size_t offset, size_t length, void const *pSource, bool discardWholeBuffer)\n"
    "    void DefaultHardwareIndexBuffer.write_data(size_t offset, size_t length, void const *pSource)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::DefaultHardwareIndexBuffer.lock

  call-seq:
    lock(size_t offset, size_t length, LockOptions options) -> void

An instance method.

*/
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);
  {
    try {
      result = (void *)(arg1)->lock(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultHardwareIndexBuffer.unlock

  call-seq:
    unlock

An instance method.

*/
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);
  {
    try {
      (arg1)->unlock();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DefaultHardwareBufferManagerBase < Ogre::Ogre::HardwareBufferManagerBase

  Proxy of C++ Ogre::DefaultHardwareBufferManagerBase class


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


/*
  Document-method: Ogre::DefaultHardwareBufferManagerBase.new

  call-seq:
    DefaultHardwareBufferManagerBase.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::DefaultHardwareBufferManagerBase *)new Ogre::DefaultHardwareBufferManagerBase();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultHardwareBufferManagerBase(Ogre::DefaultHardwareBufferManagerBase *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DefaultHardwareBufferManagerBase.create_vertex_buffer

  call-seq:
    create_vertex_buffer(size_t vertexSize, size_t numVerts, Usage usage, bool useShadowBuffer=false) -> HardwareVertexBufferSharedPtr
    create_vertex_buffer(size_t vertexSize, size_t numVerts, Usage usage) -> HardwareVertexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultHardwareBufferManagerBase_create_vertex_buffer__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);
  {
    try {
      result = (arg1)->createVertexBuffer(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_create_vertex_buffer__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);
  {
    try {
      result = (arg1)->createVertexBuffer(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_create_vertex_buffer(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_create_vertex_buffer__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_create_vertex_buffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "DefaultHardwareBufferManagerBase.create_vertex_buffer", 
    "    Ogre::HardwareVertexBufferSharedPtr DefaultHardwareBufferManagerBase.create_vertex_buffer(size_t vertexSize, size_t numVerts, Ogre::HardwareBuffer::Usage usage, bool useShadowBuffer)\n"
    "    Ogre::HardwareVertexBufferSharedPtr DefaultHardwareBufferManagerBase.create_vertex_buffer(size_t vertexSize, size_t numVerts, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::DefaultHardwareBufferManagerBase.create_index_buffer

  call-seq:
    create_index_buffer(IndexType itype, size_t numIndexes, Usage usage, bool useShadowBuffer=false) -> HardwareIndexBufferSharedPtr
    create_index_buffer(IndexType itype, size_t numIndexes, Usage usage) -> HardwareIndexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultHardwareBufferManagerBase_create_index_buffer__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);
  {
    try {
      result = (arg1)->createIndexBuffer(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_create_index_buffer__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);
  {
    try {
      result = (arg1)->createIndexBuffer(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_create_index_buffer(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_create_index_buffer__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_create_index_buffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "DefaultHardwareBufferManagerBase.create_index_buffer", 
    "    Ogre::HardwareIndexBufferSharedPtr DefaultHardwareBufferManagerBase.create_index_buffer(Ogre::HardwareIndexBuffer::IndexType itype, size_t numIndexes, Ogre::HardwareBuffer::Usage usage, bool useShadowBuffer)\n"
    "    Ogre::HardwareIndexBufferSharedPtr DefaultHardwareBufferManagerBase.create_index_buffer(Ogre::HardwareIndexBuffer::IndexType itype, size_t numIndexes, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::DefaultHardwareBufferManagerBase.create_render_to_vertex_buffer

  call-seq:
    create_render_to_vertex_buffer -> RenderToVertexBufferSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultHardwareBufferManagerBase_create_render_to_vertex_buffer(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);
  {
    try {
      result = (arg1)->createRenderToVertexBuffer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::RenderToVertexBufferSharedPtr(static_cast< const Ogre::RenderToVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DefaultHardwareBufferManager < Ogre::Ogre::HardwareBufferManager

  Proxy of C++ Ogre::DefaultHardwareBufferManager class


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


/*
  Document-method: Ogre::DefaultHardwareBufferManager.new

  call-seq:
    DefaultHardwareBufferManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::DefaultHardwareBufferManager *)new Ogre::DefaultHardwareBufferManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultHardwareBufferManager(Ogre::DefaultHardwareBufferManager *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::DeflateStream < Ogre::Ogre::DataStream

  Proxy of C++ Ogre::DeflateStream class


*/
swig_class SwigClassDeflateStream;


/*
  Document-method: Ogre::DeflateStream.new

  call-seq:
    DeflateStream.new(DataStreamPtr compressedStream, String tmpFileName="")
    DeflateStream.new(DataStreamPtr compressedStream)
    DeflateStream.new(String name, DataStreamPtr compressedStream, String tmpFileName="")
    DeflateStream.new(String name, DataStreamPtr compressedStream)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::DeflateStream *)new Ogre::DeflateStream((Ogre::DataStreamPtr const &)*arg1,(Ogre::String const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::DeflateStream *)new Ogre::DeflateStream((Ogre::DataStreamPtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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;
  }
  {
    try {
      result = (Ogre::DeflateStream *)new Ogre::DeflateStream((Ogre::String const &)*arg1,(Ogre::DataStreamPtr const &)*arg2,(Ogre::String const &)*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::DeflateStream *)new Ogre::DeflateStream((Ogre::String const &)*arg1,(Ogre::DataStreamPtr const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::DeflateStream.is_compressed_stream_valid

  call-seq:
    is_compressed_stream_valid -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_DeflateStream_is_compressed_stream_valid(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);
  {
    try {
      result = (bool)((Ogre::DeflateStream const *)arg1)->isCompressedStreamValid();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DeflateStream.read

  call-seq:
    read(void buf, size_t count) -> size_t

An instance method.

*/
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);
  {
    try {
      result = (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DeflateStream.write

  call-seq:
    write(void buf, size_t count) -> size_t

An instance method.

*/
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);
  {
    try {
      result = (arg1)->write((void const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DeflateStream.skip

  call-seq:
    skip(long count)

An instance method.

*/
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);
  {
    try {
      (arg1)->skip(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DeflateStream.seek

  call-seq:
    seek(size_t pos)

An instance method.

*/
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);
  {
    try {
      (arg1)->seek(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DeflateStream.tell

  call-seq:
    tell -> size_t

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::DeflateStream const *)arg1)->tell();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DeflateStream.eof

  call-seq:
    eof -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::DeflateStream const *)arg1)->eof();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DeflateStream.close

  call-seq:
    close

An instance method.

*/
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);
  {
    try {
      (arg1)->close();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DepthBuffer

  Proxy of C++ Ogre::DepthBuffer class


*/
swig_class SwigClassDepthBuffer;


/*
  Document-method: Ogre::PoolId.POOL_NO_DEPTH

  call-seq:
    POOL_NO_DEPTH -> int

A class method.

*/

/*
  Document-method: Ogre::PoolId.POOL_MANUAL_USAGE

  call-seq:
    POOL_MANUAL_USAGE -> int

A class method.

*/

/*
  Document-method: Ogre::PoolId.POOL_DEFAULT

  call-seq:
    POOL_DEFAULT -> int

A class method.

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


/*
  Document-method: Ogre::DepthBuffer.new

  call-seq:
    DepthBuffer.new(uint16 poolId, uint16 bitDepth, uint32 width, uint32 height, 
    uint32 fsaa, String fsaaHint, bool manual)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::DepthBuffer *)new Ogre::DepthBuffer(arg1,arg2,arg3,arg4,arg5,(Ogre::String const &)*arg6,arg7);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::DepthBuffer._set_pool_id

  call-seq:
    _set_pool_id(uint16 poolId)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DepthBuffer__set_pool_id(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);
  {
    try {
      (arg1)->_setPoolId(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DepthBuffer.get_pool_id

  call-seq:
    get_pool_id -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_DepthBuffer_get_pool_id(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::DepthBuffer const *)arg1)->getPoolId();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DepthBuffer.get_bit_depth

  call-seq:
    get_bit_depth -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_DepthBuffer_get_bit_depth(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::DepthBuffer const *)arg1)->getBitDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DepthBuffer.get_width

  call-seq:
    get_width -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_DepthBuffer_get_width(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::DepthBuffer const *)arg1)->getWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DepthBuffer.get_height

  call-seq:
    get_height -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_DepthBuffer_get_height(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::DepthBuffer const *)arg1)->getHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DepthBuffer.get_fsaa

  call-seq:
    get_fsaa -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_DepthBuffer_get_fsaa(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::DepthBuffer const *)arg1)->getFsaa();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DepthBuffer.get_fsaa_hint

  call-seq:
    get_fsaa_hint -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_DepthBuffer_get_fsaa_hint(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::DepthBuffer const *)arg1)->getFsaaHint();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DepthBuffer.is_manual

  call-seq:
    is_manual -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_DepthBuffer_is_manual(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);
  {
    try {
      result = (bool)((Ogre::DepthBuffer const *)arg1)->isManual();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DepthBuffer.is_compatible

  call-seq:
    is_compatible(RenderTarget renderTarget) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_DepthBuffer_is_compatible(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);
  {
    try {
      result = (bool)((Ogre::DepthBuffer const *)arg1)->isCompatible(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DepthBuffer._notify_render_target_attached

  call-seq:
    _notify_render_target_attached(RenderTarget renderTarget)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DepthBuffer__notify_render_target_attached(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);
  {
    try {
      (arg1)->_notifyRenderTargetAttached(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DepthBuffer._notify_render_target_detached

  call-seq:
    _notify_render_target_detached(RenderTarget renderTarget)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DepthBuffer__notify_render_target_detached(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);
  {
    try {
      (arg1)->_notifyRenderTargetDetached(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::LodStrategy

  Proxy of C++ Ogre::LodStrategy class


*/
swig_class SwigClassLodStrategy;

SWIGINTERN void
free_Ogre_LodStrategy(Ogre::LodStrategy *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::LodStrategy.get_base_value

  call-seq:
    get_base_value -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategy_get_base_value(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);
  {
    try {
      result = (Ogre::Real)((Ogre::LodStrategy const *)arg1)->getBaseValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategy.transform_bias

  call-seq:
    transform_bias(Real factor) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategy_transform_bias(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);
  {
    try {
      result = (Ogre::Real)((Ogre::LodStrategy const *)arg1)->transformBias(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategy.transform_user_value

  call-seq:
    transform_user_value(Real userValue) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategy_transform_user_value(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);
  {
    try {
      result = (Ogre::Real)((Ogre::LodStrategy const *)arg1)->transformUserValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategy.get_value

  call-seq:
    get_value(MovableObject movableObject, Camera camera) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategy_get_value(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);
  {
    try {
      result = (Ogre::Real)((Ogre::LodStrategy const *)arg1)->getValue((Ogre::MovableObject const *)arg2,(Ogre::Camera const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategy.get_index

  call-seq:
    get_index(Real value, MeshLodUsageList meshLodUsageList) -> ushort
    get_index(Real value, LodValueList materialLodValueList) -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategy_get_index__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);
  {
    try {
      result = (Ogre::ushort)((Ogre::LodStrategy const *)arg1)->getIndex(arg2,(Ogre::Mesh::MeshLodUsageList const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategy_get_index__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);
  {
    try {
      result = (Ogre::ushort)((Ogre::LodStrategy const *)arg1)->getIndex(arg2,(Ogre::Material::LodValueList const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_LodStrategy_get_index(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_get_index__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_get_index__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "LodStrategy.get_index", 
    "    Ogre::ushort LodStrategy.get_index(Ogre::Real value, Ogre::Mesh::MeshLodUsageList const &meshLodUsageList)\n"
    "    Ogre::ushort LodStrategy.get_index(Ogre::Real value, Ogre::Material::LodValueList const &materialLodValueList)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategy.sort

  call-seq:
    sort(MeshLodUsageList meshLodUsageList)

An instance method.

*/
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);
  {
    try {
      ((Ogre::LodStrategy const *)arg1)->sort(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategy.is_sorted

  call-seq:
    is_sorted(LodValueList values) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategy_is_sorted(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);
  {
    try {
      result = (bool)((Ogre::LodStrategy const *)arg1)->isSorted((Ogre::Mesh::LodValueList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategy.assert_sorted

  call-seq:
    assert_sorted(LodValueList values)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategy_assert_sorted(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);
  {
    try {
      ((Ogre::LodStrategy const *)arg1)->assertSorted((Ogre::Mesh::LodValueList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategy.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategy_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::LodStrategy const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DistanceLodStrategy < Ogre::Ogre::LodStrategy

  Proxy of C++ Ogre::DistanceLodStrategy class


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


/*
  Document-method: Ogre::DistanceLodStrategy.new

  call-seq:
    DistanceLodStrategy.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::DistanceLodStrategy *)new Ogre::DistanceLodStrategy();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DistanceLodStrategy.get_base_value

  call-seq:
    get_base_value -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_DistanceLodStrategy_get_base_value(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);
  {
    try {
      result = (Ogre::Real)((Ogre::DistanceLodStrategy const *)arg1)->getBaseValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DistanceLodStrategy.transform_bias

  call-seq:
    transform_bias(Real factor) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_DistanceLodStrategy_transform_bias(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);
  {
    try {
      result = (Ogre::Real)((Ogre::DistanceLodStrategy const *)arg1)->transformBias(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DistanceLodStrategy.transform_user_value

  call-seq:
    transform_user_value(Real userValue) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_DistanceLodStrategy_transform_user_value(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);
  {
    try {
      result = (Ogre::Real)((Ogre::DistanceLodStrategy const *)arg1)->transformUserValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DistanceLodStrategy.get_index

  call-seq:
    get_index(Real value, MeshLodUsageList meshLodUsageList) -> ushort
    get_index(Real value, LodValueList materialLodValueList) -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_DistanceLodStrategy_get_index__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);
  {
    try {
      result = (Ogre::ushort)((Ogre::DistanceLodStrategy const *)arg1)->getIndex(arg2,(Ogre::Mesh::MeshLodUsageList const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_get_index__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);
  {
    try {
      result = (Ogre::ushort)((Ogre::DistanceLodStrategy const *)arg1)->getIndex(arg2,(Ogre::Material::LodValueList const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DistanceLodStrategy_get_index(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_get_index__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_get_index__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "DistanceLodStrategy.get_index", 
    "    Ogre::ushort DistanceLodStrategy.get_index(Ogre::Real value, Ogre::Mesh::MeshLodUsageList const &meshLodUsageList)\n"
    "    Ogre::ushort DistanceLodStrategy.get_index(Ogre::Real value, Ogre::Material::LodValueList const &materialLodValueList)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::DistanceLodStrategy.sort

  call-seq:
    sort(MeshLodUsageList meshLodUsageList)

An instance method.

*/
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);
  {
    try {
      ((Ogre::DistanceLodStrategy const *)arg1)->sort(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DistanceLodStrategy.is_sorted

  call-seq:
    is_sorted(LodValueList values) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_DistanceLodStrategy_is_sorted(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);
  {
    try {
      result = (bool)((Ogre::DistanceLodStrategy const *)arg1)->isSorted((Ogre::Mesh::LodValueList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DistanceLodStrategy.set_reference_view

  call-seq:
    set_reference_view(Real viewportWidth, Real viewportHeight, Radian fovY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DistanceLodStrategy_set_reference_view(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));
    }
  }
  {
    try {
      (arg1)->setReferenceView(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DistanceLodStrategy.set_reference_view_enabled

  call-seq:
    set_reference_view_enabled(bool value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DistanceLodStrategy_set_reference_view_enabled(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);
  {
    try {
      (arg1)->setReferenceViewEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DistanceLodStrategy.get_reference_view_enabled

  call-seq:
    get_reference_view_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_DistanceLodStrategy_get_reference_view_enabled(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);
  {
    try {
      result = (bool)((Ogre::DistanceLodStrategy const *)arg1)->getReferenceViewEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DistanceLodStrategy.get_singleton

  call-seq:
    get_singleton -> DistanceLodStrategy

A class method.

*/
SWIGINTERN VALUE
_wrap_DistanceLodStrategy_get_singleton(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;
  }
  {
    try {
      result = (Ogre::DistanceLodStrategy *) &Ogre::DistanceLodStrategy::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DistanceLodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DistanceLodStrategy.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> DistanceLodStrategy

A class method.

*/
SWIGINTERN VALUE
_wrap_DistanceLodStrategy_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::DistanceLodStrategy *)Ogre::DistanceLodStrategy::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DistanceLodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DistanceLodStrategy(Ogre::DistanceLodStrategy *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::DualQuaternion

  Proxy of C++ Ogre::DualQuaternion class


*/
swig_class SwigClassDualQuaternion;


/*
  Document-method: Ogre::DualQuaternion.new

  call-seq:
    DualQuaternion.new
    DualQuaternion.new(Real fW, Real fX, Real fY, Real fZ, Real fdW, Real fdX, 
    Real fdY, Real fdZ)
    DualQuaternion.new(Matrix4 rot)
    DualQuaternion.new(Quaternion q, Vector3 trans)
    DualQuaternion.new(Real valptr)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::DualQuaternion *)new Ogre::DualQuaternion();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::DualQuaternion *)new Ogre::DualQuaternion(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::DualQuaternion *)new Ogre::DualQuaternion((Ogre::Matrix4 const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::DualQuaternion *)new Ogre::DualQuaternion((Ogre::Quaternion const &)*arg1,(Ogre::Vector3 const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::DualQuaternion *)new Ogre::DualQuaternion(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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);
  {
    try {
      result = (bool)((Ogre::DualQuaternion const *)arg1)->operator ==((Ogre::DualQuaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DualQuaternion.ptr

  call-seq:
    ptr -> Real
    ptr -> Real

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Real *)(arg1)->ptr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Real *)((Ogre::DualQuaternion const *)arg1)->ptr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::DualQuaternion.swap

  call-seq:
    swap(DualQuaternion other)

An instance method.

*/
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);
  {
    try {
      (arg1)->swap(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DualQuaternion.is_na_n

  call-seq:
    is_na_n -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_DualQuaternion_is_na_n(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);
  {
    try {
      result = (bool)((Ogre::DualQuaternion const *)arg1)->isNaN();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DualQuaternion.from_rotation_translation

  call-seq:
    from_rotation_translation(Quaternion q, Vector3 trans)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DualQuaternion_from_rotation_translation(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);
  {
    try {
      (arg1)->fromRotationTranslation((Ogre::Quaternion const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DualQuaternion.to_rotation_translation

  call-seq:
    to_rotation_translation(Quaternion q, Vector3 translation)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DualQuaternion_to_rotation_translation(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);
  {
    try {
      ((Ogre::DualQuaternion const *)arg1)->toRotationTranslation(*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DualQuaternion.from_transformation_matrix

  call-seq:
    from_transformation_matrix(Matrix4 kTrans)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DualQuaternion_from_transformation_matrix(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);
  {
    try {
      (arg1)->fromTransformationMatrix((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DualQuaternion.to_transformation_matrix

  call-seq:
    to_transformation_matrix(Matrix4 kTrans)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DualQuaternion_to_transformation_matrix(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);
  {
    try {
      ((Ogre::DualQuaternion const *)arg1)->toTransformationMatrix(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DualQuaternion.w

  call-seq:
    w -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::DualQuaternion.w=

  call-seq:
    w=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::DualQuaternion.x

  call-seq:
    x -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::DualQuaternion.x=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::DualQuaternion.y

  call-seq:
    y -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::DualQuaternion.y=

  call-seq:
    y=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::DualQuaternion.z

  call-seq:
    z -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::DualQuaternion.z=

  call-seq:
    z=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::DualQuaternion.dw

  call-seq:
    dw -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::DualQuaternion.dw=

  call-seq:
    dw=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::DualQuaternion.dx

  call-seq:
    dx -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::DualQuaternion.dx=

  call-seq:
    dx=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::DualQuaternion.dy

  call-seq:
    dy -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::DualQuaternion.dy=

  call-seq:
    dy=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::DualQuaternion.dz

  call-seq:
    dz -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::DualQuaternion.dz=

  call-seq:
    dz=(x) -> Real

Set new value for attribute.

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


/*
  Document-class: Ogre::DynLib

  Proxy of C++ Ogre::DynLib class


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


/*
  Document-method: Ogre::DynLib.new

  call-seq:
    DynLib.new(String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::DynLib *)new Ogre::DynLib((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::DynLib.load

  call-seq:
    load

An instance method.

*/
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);
  {
    try {
      (arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DynLib.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DynLib.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_DynLib_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::DynLib const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DynLib.get_symbol

  call-seq:
    get_symbol(String strName) -> void

An instance method.

*/
SWIGINTERN VALUE
_wrap_DynLib_get_symbol(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;
  }
  {
    try {
      result = (void *)((Ogre::DynLib const *)arg1)->getSymbol((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-class: Ogre::DynLibManager

  Proxy of C++ Ogre::DynLibManager class


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


/*
  Document-method: Ogre::DynLibManager.new

  call-seq:
    DynLibManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::DynLibManager *)new Ogre::DynLibManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DynLibManager(Ogre::DynLibManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DynLibManager.load

  call-seq:
    load(String filename) -> DynLib

An instance method.

*/
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;
  }
  {
    try {
      result = (Ogre::DynLib *)(arg1)->load((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DynLib, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::DynLibManager.unload

  call-seq:
    unload(DynLib lib)

An instance method.

*/
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);
  {
    try {
      (arg1)->unload(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DynLibManager.get_singleton

  call-seq:
    get_singleton -> DynLibManager

A class method.

*/
SWIGINTERN VALUE
_wrap_DynLibManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::DynLibManager *) &Ogre::DynLibManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DynLibManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DynLibManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> DynLibManager

A class method.

*/
SWIGINTERN VALUE
_wrap_DynLibManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::DynLibManager *)Ogre::DynLibManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DynLibManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::EdgeData

  Proxy of C++ Ogre::EdgeData class


*/
swig_class SwigClassEdgeData;


/*
  Document-method: Ogre::EdgeData.triangles

  call-seq:
    triangles -> TriangleList

Get value of attribute.

*/

/*
  Document-method: Ogre::EdgeData.triangles=

  call-seq:
    triangles=(x) -> TriangleList

Set new value for attribute.

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



/*
  Document-method: Ogre::EdgeData.triangleFaceNormals

  call-seq:
    triangleFaceNormals -> TriangleFaceNormalList

Get value of attribute.

*/

/*
  Document-method: Ogre::EdgeData.triangleFaceNormals=

  call-seq:
    triangleFaceNormals=(x) -> TriangleFaceNormalList

Set new value for attribute.

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



/*
  Document-method: Ogre::EdgeData.triangleLightFacings

  call-seq:
    triangleLightFacings -> TriangleLightFacingList

Get value of attribute.

*/

/*
  Document-method: Ogre::EdgeData.triangleLightFacings=

  call-seq:
    triangleLightFacings=(x) -> TriangleLightFacingList

Set new value for attribute.

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



/*
  Document-method: Ogre::EdgeData.edgeGroups

  call-seq:
    edgeGroups -> EdgeGroupList

Get value of attribute.

*/

/*
  Document-method: Ogre::EdgeData.edgeGroups=

  call-seq:
    edgeGroups=(x) -> EdgeGroupList

Set new value for attribute.

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



/*
  Document-method: Ogre::EdgeData.isClosed

  call-seq:
    isClosed -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::EdgeData.isClosed=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::EdgeData.update_triangle_light_facing

  call-seq:
    update_triangle_light_facing(Vector4 lightPos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_EdgeData_update_triangle_light_facing(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);
  {
    try {
      (arg1)->updateTriangleLightFacing((Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::EdgeData.update_face_normals

  call-seq:
    update_face_normals(size_t vertexSet, HardwareVertexBufferSharedPtr positionBuffer)

An instance method.

*/
SWIGINTERN VALUE
_wrap_EdgeData_update_face_normals(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);
  {
    try {
      (arg1)->updateFaceNormals(arg2,(Ogre::HardwareVertexBufferSharedPtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::EdgeData.log

  call-seq:
    log(Log log)

An instance method.

*/
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);
  {
    try {
      (arg1)->log(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::EdgeData.new

  call-seq:
    EdgeData.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EdgeData *)new Ogre::EdgeData();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EdgeData(Ogre::EdgeData *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::EdgeListBuilder

  Proxy of C++ Ogre::EdgeListBuilder class


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


/*
  Document-method: Ogre::EdgeListBuilder.new

  call-seq:
    EdgeListBuilder.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EdgeListBuilder *)new Ogre::EdgeListBuilder();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EdgeListBuilder(Ogre::EdgeListBuilder *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::EdgeListBuilder.add_vertex_data

  call-seq:
    add_vertex_data(VertexData vertexData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_EdgeListBuilder_add_vertex_data(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);
  {
    try {
      (arg1)->addVertexData((Ogre::VertexData const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::EdgeListBuilder.add_index_data

  call-seq:
    add_index_data(IndexData indexData, size_t vertexSet=0, OperationType opType=OT_TRIANGLE_LIST)
    add_index_data(IndexData indexData, size_t vertexSet=0)
    add_index_data(IndexData indexData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_EdgeListBuilder_add_index_data__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);
  {
    try {
      (arg1)->addIndexData((Ogre::IndexData const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeListBuilder_add_index_data__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);
  {
    try {
      (arg1)->addIndexData((Ogre::IndexData const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeListBuilder_add_index_data__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);
  {
    try {
      (arg1)->addIndexData((Ogre::IndexData const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_EdgeListBuilder_add_index_data(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_add_index_data__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_add_index_data__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_add_index_data__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "EdgeListBuilder.add_index_data", 
    "    void EdgeListBuilder.add_index_data(Ogre::IndexData const *indexData, size_t vertexSet, Ogre::RenderOperation::OperationType opType)\n"
    "    void EdgeListBuilder.add_index_data(Ogre::IndexData const *indexData, size_t vertexSet)\n"
    "    void EdgeListBuilder.add_index_data(Ogre::IndexData const *indexData)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::EdgeListBuilder.build

  call-seq:
    build -> EdgeData

An instance method.

*/
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);
  {
    try {
      result = (Ogre::EdgeData *)(arg1)->build();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::EdgeListBuilder.log

  call-seq:
    log(Log l)

An instance method.

*/
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);
  {
    try {
      (arg1)->log(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Entity < Ogre::Ogre::MovableObject

  Proxy of C++ Ogre::Entity class


*/
swig_class SwigClassEntity;

SWIGINTERN void
free_Ogre_Entity(Ogre::Entity *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Entity.get_mesh

  call-seq:
    get_mesh -> MeshPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_mesh(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);
  {
    try {
      result = (Ogre::MeshPtr *) &((Ogre::Entity const *)arg1)->getMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_sub_entity

  call-seq:
    get_sub_entity(unsigned int index) -> SubEntity
    get_sub_entity(String name) -> SubEntity

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_sub_entity__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);
  {
    try {
      result = (Ogre::SubEntity *)((Ogre::Entity const *)arg1)->getSubEntity(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubEntity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_get_sub_entity__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;
  }
  {
    try {
      result = (Ogre::SubEntity *)((Ogre::Entity const *)arg1)->getSubEntity((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_sub_entity(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_get_sub_entity__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_get_sub_entity__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Entity.get_sub_entity", 
    "    Ogre::SubEntity * Entity.get_sub_entity(unsigned int index)\n"
    "    Ogre::SubEntity * Entity.get_sub_entity(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_num_sub_entities

  call-seq:
    get_num_sub_entities -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_num_sub_entities(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);
  {
    try {
      result = (unsigned int)((Ogre::Entity const *)arg1)->getNumSubEntities();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Entity *)((Ogre::Entity const *)arg1)->clone((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Entity.set_material_name

  call-seq:
    set_material_name(String name, String groupName=AUTODETECT_RESOURCE_GROUP_NAME)
    set_material_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_set_material_name(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_set_material_name__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_set_material_name__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Entity.set_material_name", 
    "    void Entity.set_material_name(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    void Entity.set_material_name(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Entity.set_material

  call-seq:
    set_material(MaterialPtr material)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_set_material(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);
  {
    try {
      (arg1)->setMaterial((Ogre::MaterialPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._notify_current_camera

  call-seq:
    _notify_current_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__notify_current_camera(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);
  {
    try {
      (arg1)->_notifyCurrentCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.set_render_queue_group

  call-seq:
    set_render_queue_group(uint8 queueID)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_set_render_queue_group(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);
  {
    try {
      (arg1)->setRenderQueueGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.set_render_queue_group_and_priority

  call-seq:
    set_render_queue_group_and_priority(uint8 queueID, ushort priority)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_set_render_queue_group_and_priority(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);
  {
    try {
      (arg1)->setRenderQueueGroupAndPriority(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::Entity const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_child_objects_bounding_box

  call-seq:
    get_child_objects_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_child_objects_bounding_box(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);
  {
    try {
      result = ((Ogre::Entity const *)arg1)->getChildObjectsBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::AxisAlignedBox(static_cast< const Ogre::AxisAlignedBox& >(result))), SWIGTYPE_p_Ogre__AxisAlignedBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Entity const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_animation_state

  call-seq:
    get_animation_state(String name) -> AnimationState

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_animation_state(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;
  }
  {
    try {
      result = (Ogre::AnimationState *)((Ogre::Entity const *)arg1)->getAnimationState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Entity.has_animation_state

  call-seq:
    has_animation_state(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_has_animation_state(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;
  }
  {
    try {
      result = (bool)((Ogre::Entity const *)arg1)->hasAnimationState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_all_animation_states

  call-seq:
    get_all_animation_states -> AnimationStateSet

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_all_animation_states(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);
  {
    try {
      result = (Ogre::AnimationStateSet *)((Ogre::Entity const *)arg1)->getAllAnimationStates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.set_display_skeleton

  call-seq:
    set_display_skeleton(bool display)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_set_display_skeleton(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);
  {
    try {
      (arg1)->setDisplaySkeleton(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_display_skeleton

  call-seq:
    get_display_skeleton -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_display_skeleton(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);
  {
    try {
      result = (bool)((Ogre::Entity const *)arg1)->getDisplaySkeleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_manual_lod_level

  call-seq:
    get_manual_lod_level(size_t index) -> Entity

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_manual_lod_level(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);
  {
    try {
      result = (Ogre::Entity *)((Ogre::Entity const *)arg1)->getManualLodLevel(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_num_manual_lod_levels

  call-seq:
    get_num_manual_lod_levels -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_num_manual_lod_levels(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);
  {
    try {
      result = ((Ogre::Entity const *)arg1)->getNumManualLodLevels();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_current_lod_index

  call-seq:
    get_current_lod_index -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_current_lod_index(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);
  {
    try {
      result = (Ogre::ushort)(arg1)->getCurrentLodIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.set_mesh_lod_bias

  call-seq:
    set_mesh_lod_bias(Real factor, ushort maxDetailIndex=0, ushort minDetailIndex=99)
    set_mesh_lod_bias(Real factor, ushort maxDetailIndex=0)
    set_mesh_lod_bias(Real factor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_set_mesh_lod_bias__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);
  {
    try {
      (arg1)->setMeshLodBias(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_set_mesh_lod_bias__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);
  {
    try {
      (arg1)->setMeshLodBias(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_set_mesh_lod_bias__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);
  {
    try {
      (arg1)->setMeshLodBias(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_set_mesh_lod_bias(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_set_mesh_lod_bias__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_set_mesh_lod_bias__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_set_mesh_lod_bias__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Entity.set_mesh_lod_bias", 
    "    void Entity.set_mesh_lod_bias(Ogre::Real factor, Ogre::ushort maxDetailIndex, Ogre::ushort minDetailIndex)\n"
    "    void Entity.set_mesh_lod_bias(Ogre::Real factor, Ogre::ushort maxDetailIndex)\n"
    "    void Entity.set_mesh_lod_bias(Ogre::Real factor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Entity.set_material_lod_bias

  call-seq:
    set_material_lod_bias(Real factor, ushort maxDetailIndex=0, ushort minDetailIndex=99)
    set_material_lod_bias(Real factor, ushort maxDetailIndex=0)
    set_material_lod_bias(Real factor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_set_material_lod_bias__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);
  {
    try {
      (arg1)->setMaterialLodBias(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_set_material_lod_bias__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);
  {
    try {
      (arg1)->setMaterialLodBias(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_set_material_lod_bias__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);
  {
    try {
      (arg1)->setMaterialLodBias(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_set_material_lod_bias(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_set_material_lod_bias__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_set_material_lod_bias__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_set_material_lod_bias__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Entity.set_material_lod_bias", 
    "    void Entity.set_material_lod_bias(Ogre::Real factor, Ogre::ushort maxDetailIndex, Ogre::ushort minDetailIndex)\n"
    "    void Entity.set_material_lod_bias(Ogre::Real factor, Ogre::ushort maxDetailIndex)\n"
    "    void Entity.set_material_lod_bias(Ogre::Real factor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Entity.set_polygon_mode_overrideable

  call-seq:
    set_polygon_mode_overrideable(bool PolygonModeOverrideable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_set_polygon_mode_overrideable(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);
  {
    try {
      (arg1)->setPolygonModeOverrideable(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.attach_object_to_bone

  call-seq:
    attach_object_to_bone(String boneName, MovableObject pMovable, Quaternion offsetOrientation=IDENTITY, 
    Vector3 offsetPosition=) -> TagPoint
    attach_object_to_bone(String boneName, MovableObject pMovable, Quaternion offsetOrientation=IDENTITY) -> TagPoint
    attach_object_to_bone(String boneName, MovableObject pMovable) -> TagPoint

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_attach_object_to_bone__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);
  {
    try {
      result = (Ogre::TagPoint *)(arg1)->attachObjectToBone((Ogre::String const &)*arg2,arg3,(Ogre::Quaternion const &)*arg4,(Ogre::Vector3 const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_attach_object_to_bone__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);
  {
    try {
      result = (Ogre::TagPoint *)(arg1)->attachObjectToBone((Ogre::String const &)*arg2,arg3,(Ogre::Quaternion const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_attach_object_to_bone__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);
  {
    try {
      result = (Ogre::TagPoint *)(arg1)->attachObjectToBone((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_attach_object_to_bone(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_attach_object_to_bone__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_attach_object_to_bone__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_attach_object_to_bone__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Entity.attach_object_to_bone", 
    "    Ogre::TagPoint * Entity.attach_object_to_bone(Ogre::String const &boneName, Ogre::MovableObject *pMovable, Ogre::Quaternion const &offsetOrientation, Ogre::Vector3 const &offsetPosition)\n"
    "    Ogre::TagPoint * Entity.attach_object_to_bone(Ogre::String const &boneName, Ogre::MovableObject *pMovable, Ogre::Quaternion const &offsetOrientation)\n"
    "    Ogre::TagPoint * Entity.attach_object_to_bone(Ogre::String const &boneName, Ogre::MovableObject *pMovable)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Entity.detach_object_from_bone

  call-seq:
    detach_object_from_bone(String movableName) -> MovableObject
    detach_object_from_bone(MovableObject obj)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_detach_object_from_bone__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;
  }
  {
    try {
      result = (Ogre::MovableObject *)(arg1)->detachObjectFromBone((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_detach_object_from_bone__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);
  {
    try {
      (arg1)->detachObjectFromBone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_detach_object_from_bone(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_detach_object_from_bone__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_detach_object_from_bone__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Entity.detach_object_from_bone", 
    "    void Entity.detach_object_from_bone(Ogre::String const &movableName)\n"
    "    void Entity.detach_object_from_bone(Ogre::MovableObject *obj)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Entity.detach_all_objects_from_bone

  call-seq:
    detach_all_objects_from_bone

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_detach_all_objects_from_bone(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);
  {
    try {
      (arg1)->detachAllObjectsFromBone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_attached_object_iterator

  call-seq:
    get_attached_object_iterator -> ChildObjectListIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_attached_object_iterator(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);
  {
    try {
      result = (arg1)->getAttachedObjectIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Entity.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Entity const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_world_bounding_box

  call-seq:
    get_world_bounding_box(bool derive=false) -> AxisAlignedBox
    get_world_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_world_bounding_box__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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::Entity const *)arg1)->getWorldBoundingBox(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_get_world_bounding_box__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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::Entity const *)arg1)->getWorldBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_get_world_bounding_box(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_get_world_bounding_box__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_get_world_bounding_box__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Entity.get_world_bounding_box", 
    "    Ogre::AxisAlignedBox const & Entity.get_world_bounding_box(bool derive)\n"
    "    Ogre::AxisAlignedBox const & Entity.get_world_bounding_box()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_world_bounding_sphere

  call-seq:
    get_world_bounding_sphere(bool derive=false) -> Sphere
    get_world_bounding_sphere -> Sphere

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_world_bounding_sphere__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);
  {
    try {
      result = (Ogre::Sphere *) &((Ogre::Entity const *)arg1)->getWorldBoundingSphere(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_get_world_bounding_sphere__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);
  {
    try {
      result = (Ogre::Sphere *) &((Ogre::Entity const *)arg1)->getWorldBoundingSphere();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_get_world_bounding_sphere(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_get_world_bounding_sphere__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_get_world_bounding_sphere__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Entity.get_world_bounding_sphere", 
    "    Ogre::Sphere const & Entity.get_world_bounding_sphere(bool derive)\n"
    "    Ogre::Sphere const & Entity.get_world_bounding_sphere()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_edge_list

  call-seq:
    get_edge_list -> EdgeData

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_edge_list(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);
  {
    try {
      result = (Ogre::EdgeData *)(arg1)->getEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.has_edge_list

  call-seq:
    has_edge_list -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_has_edge_list(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);
  {
    try {
      result = (bool)(arg1)->hasEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_shadow_volume_renderable_iterator

  call-seq:
    get_shadow_volume_renderable_iterator(ShadowTechnique shadowTechnique, Light light, HardwareIndexBufferSharedPtr indexBuffer, 
    bool extrudeVertices, 
    Real extrusionDistance, unsigned long flags=0) -> ShadowRenderableListIterator
    get_shadow_volume_renderable_iterator(ShadowTechnique shadowTechnique, Light light, HardwareIndexBufferSharedPtr indexBuffer, 
    bool extrudeVertices, 
    Real extrusionDistance) -> ShadowRenderableListIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_shadow_volume_renderable_iterator__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);
  {
    try {
      result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_shadow_volume_renderable_iterator__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);
  {
    try {
      result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_shadow_volume_renderable_iterator(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_get_shadow_volume_renderable_iterator__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_get_shadow_volume_renderable_iterator__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Entity.get_shadow_volume_renderable_iterator", 
    "    Ogre::ShadowCaster::ShadowRenderableListIterator Entity.get_shadow_volume_renderable_iterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDistance, unsigned long flags)\n"
    "    Ogre::ShadowCaster::ShadowRenderableListIterator Entity.get_shadow_volume_renderable_iterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDistance)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Entity._get_bone_matrices

  call-seq:
    _get_bone_matrices -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__get_bone_matrices(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);
  {
    try {
      result = (Ogre::Matrix4 *)((Ogre::Entity const *)arg1)->_getBoneMatrices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._get_num_bone_matrices

  call-seq:
    _get_num_bone_matrices -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__get_num_bone_matrices(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);
  {
    try {
      result = (unsigned short)((Ogre::Entity const *)arg1)->_getNumBoneMatrices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.has_skeleton

  call-seq:
    has_skeleton -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_has_skeleton(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);
  {
    try {
      result = (bool)((Ogre::Entity const *)arg1)->hasSkeleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_skeleton

  call-seq:
    get_skeleton -> SkeletonInstance

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_skeleton(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);
  {
    try {
      result = (Ogre::SkeletonInstance *)((Ogre::Entity const *)arg1)->getSkeleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.is_hardware_animation_enabled

  call-seq:
    is_hardware_animation_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_is_hardware_animation_enabled(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);
  {
    try {
      result = (bool)(arg1)->isHardwareAnimationEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._notify_attached

  call-seq:
    _notify_attached(Node parent, bool isTagPoint=false)
    _notify_attached(Node parent)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity__notify_attached(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__notify_attached__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__notify_attached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Entity._notify_attached", 
    "    void Entity._notify_attached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void Entity._notify_attached(Ogre::Node *parent)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_software_animation_requests

  call-seq:
    get_software_animation_requests -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_software_animation_requests(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);
  {
    try {
      result = (int)((Ogre::Entity const *)arg1)->getSoftwareAnimationRequests();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_software_animation_normals_requests

  call-seq:
    get_software_animation_normals_requests -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_software_animation_normals_requests(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);
  {
    try {
      result = (int)((Ogre::Entity const *)arg1)->getSoftwareAnimationNormalsRequests();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.add_software_animation_request

  call-seq:
    add_software_animation_request(bool normalsAlso)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_add_software_animation_request(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);
  {
    try {
      (arg1)->addSoftwareAnimationRequest(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.remove_software_animation_request

  call-seq:
    remove_software_animation_request(bool normalsAlso)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_remove_software_animation_request(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);
  {
    try {
      (arg1)->removeSoftwareAnimationRequest(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.share_skeleton_instance_with

  call-seq:
    share_skeleton_instance_with(Entity entity)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_share_skeleton_instance_with(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);
  {
    try {
      (arg1)->shareSkeletonInstanceWith(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.has_vertex_animation

  call-seq:
    has_vertex_animation -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_has_vertex_animation(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);
  {
    try {
      result = (bool)((Ogre::Entity const *)arg1)->hasVertexAnimation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.stop_sharing_skeleton_instance

  call-seq:
    stop_sharing_skeleton_instance

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_stop_sharing_skeleton_instance(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);
  {
    try {
      (arg1)->stopSharingSkeletonInstance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.shares_skeleton_instance

  call-seq:
    shares_skeleton_instance -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_shares_skeleton_instance(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);
  {
    try {
      result = (bool)((Ogre::Entity const *)arg1)->sharesSkeletonInstance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_skeleton_instance_sharing_set

  call-seq:
    get_skeleton_instance_sharing_set -> EntitySet

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_skeleton_instance_sharing_set(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);
  {
    try {
      result = (Ogre::Entity::EntitySet *)((Ogre::Entity const *)arg1)->getSkeletonInstanceSharingSet();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::Entity.refresh_available_animation_state

  call-seq:
    refresh_available_animation_state

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_refresh_available_animation_state(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);
  {
    try {
      (arg1)->refreshAvailableAnimationState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._update_animation

  call-seq:
    _update_animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__update_animation(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);
  {
    try {
      (arg1)->_updateAnimation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._is_animated

  call-seq:
    _is_animated -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__is_animated(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);
  {
    try {
      result = (bool)((Ogre::Entity const *)arg1)->_isAnimated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._is_skeleton_animated

  call-seq:
    _is_skeleton_animated -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__is_skeleton_animated(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);
  {
    try {
      result = (bool)((Ogre::Entity const *)arg1)->_isSkeletonAnimated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._get_skel_anim_vertex_data

  call-seq:
    _get_skel_anim_vertex_data -> VertexData

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__get_skel_anim_vertex_data(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);
  {
    try {
      result = (Ogre::VertexData *)((Ogre::Entity const *)arg1)->_getSkelAnimVertexData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._get_software_vertex_anim_vertex_data

  call-seq:
    _get_software_vertex_anim_vertex_data -> VertexData

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__get_software_vertex_anim_vertex_data(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);
  {
    try {
      result = (Ogre::VertexData *)((Ogre::Entity const *)arg1)->_getSoftwareVertexAnimVertexData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._get_hardware_vertex_anim_vertex_data

  call-seq:
    _get_hardware_vertex_anim_vertex_data -> VertexData

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__get_hardware_vertex_anim_vertex_data(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);
  {
    try {
      result = (Ogre::VertexData *)((Ogre::Entity const *)arg1)->_getHardwareVertexAnimVertexData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._get_skel_anim_temp_buffer_info

  call-seq:
    _get_skel_anim_temp_buffer_info -> TempBlendedBufferInfo

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__get_skel_anim_temp_buffer_info(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);
  {
    try {
      result = (Ogre::TempBlendedBufferInfo *)(arg1)->_getSkelAnimTempBufferInfo();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TempBlendedBufferInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._get_vertex_anim_temp_buffer_info

  call-seq:
    _get_vertex_anim_temp_buffer_info -> TempBlendedBufferInfo

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__get_vertex_anim_temp_buffer_info(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);
  {
    try {
      result = (Ogre::TempBlendedBufferInfo *)(arg1)->_getVertexAnimTempBufferInfo();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TempBlendedBufferInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_type_flags

  call-seq:
    get_type_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_type_flags(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::Entity const *)arg1)->getTypeFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_vertex_data_for_binding

  call-seq:
    get_vertex_data_for_binding -> VertexData

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_vertex_data_for_binding(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);
  {
    try {
      result = (Ogre::VertexData *)(arg1)->getVertexDataForBinding();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexDataBindChoice.BIND_ORIGINAL

  call-seq:
    BIND_ORIGINAL -> int

A class method.

*/

/*
  Document-method: Ogre::VertexDataBindChoice.BIND_SOFTWARE_SKELETAL

  call-seq:
    BIND_SOFTWARE_SKELETAL -> int

A class method.

*/

/*
  Document-method: Ogre::VertexDataBindChoice.BIND_SOFTWARE_MORPH

  call-seq:
    BIND_SOFTWARE_MORPH -> int

A class method.

*/

/*
  Document-method: Ogre::VertexDataBindChoice.BIND_HARDWARE_MORPH

  call-seq:
    BIND_HARDWARE_MORPH -> int

A class method.

*/

/*
  Document-method: Ogre::Entity.choose_vertex_data_for_binding

  call-seq:
    choose_vertex_data_for_binding(bool hasVertexAnim) -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_choose_vertex_data_for_binding(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);
  {
    try {
      result = (Ogre::Entity::VertexDataBindChoice)(arg1)->chooseVertexDataForBinding(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._get_buffers_marked_for_animation

  call-seq:
    _get_buffers_marked_for_animation -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__get_buffers_marked_for_animation(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);
  {
    try {
      result = (bool)((Ogre::Entity const *)arg1)->_getBuffersMarkedForAnimation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._mark_buffers_used_for_animation

  call-seq:
    _mark_buffers_used_for_animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__mark_buffers_used_for_animation(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);
  {
    try {
      (arg1)->_markBuffersUsedForAnimation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.is_initialised

  call-seq:
    is_initialised -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_is_initialised(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);
  {
    try {
      result = (bool)((Ogre::Entity const *)arg1)->isInitialised();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity._initialise

  call-seq:
    _initialise(bool forceReinitialise=false)
    _initialise

An instance method.

*/
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);
  {
    try {
      (arg1)->_initialise(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->_initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Entity._deinitialise

  call-seq:
    _deinitialise

An instance method.

*/
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);
  {
    try {
      (arg1)->_deinitialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.background_loading_complete

  call-seq:
    background_loading_complete(Resource res)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_background_loading_complete(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);
  {
    try {
      (arg1)->backgroundLoadingComplete(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Entity.visit_renderables", 
    "    void Entity.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void Entity.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Entity._get_mesh_lod_factor_transformed

  call-seq:
    _get_mesh_lod_factor_transformed -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity__get_mesh_lod_factor_transformed(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Entity const *)arg1)->_getMeshLodFactorTransformed();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.set_skip_animation_state_update

  call-seq:
    set_skip_animation_state_update(bool skip)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_set_skip_animation_state_update(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);
  {
    try {
      (arg1)->setSkipAnimationStateUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_skip_animation_state_update

  call-seq:
    get_skip_animation_state_update -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_skip_animation_state_update(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);
  {
    try {
      result = (bool)((Ogre::Entity const *)arg1)->getSkipAnimationStateUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.set_always_update_main_skeleton

  call-seq:
    set_always_update_main_skeleton(bool update)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_set_always_update_main_skeleton(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);
  {
    try {
      (arg1)->setAlwaysUpdateMainSkeleton(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.get_always_update_main_skeleton

  call-seq:
    get_always_update_main_skeleton -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Entity_get_always_update_main_skeleton(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);
  {
    try {
      result = (bool)((Ogre::Entity const *)arg1)->getAlwaysUpdateMainSkeleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::EntityFactory < Ogre::Ogre::MovableObjectFactory

  Proxy of C++ Ogre::EntityFactory class


*/
swig_class SwigClassEntityFactory;

SWIGINTERN void
free_Ogre_EntityFactory(Ogre::EntityFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::EntityFactory.FACTORY_TYPE_NAME

  call-seq:
    FACTORY_TYPE_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::EntityFactory.FACTORY_TYPE_NAME=

  call-seq:
    FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::EntityFactory.EntityFactory_FACTORY_TYPE_NAME

  call-seq:
    EntityFactory_FACTORY_TYPE_NAME -> String

Get value of attribute.

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



/*
  Document-method: Ogre::EntityFactory.EntityFactory_FACTORY_TYPE_NAME=

  call-seq:
    EntityFactory_FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::EntityFactory.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_EntityFactory_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::EntityFactory const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::EntityFactory.destroy_instance

  call-seq:
    destroy_instance(MovableObject obj)

An instance method.

*/
SWIGINTERN VALUE
_wrap_EntityFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ExternalTextureSource < Ogre::Ogre::StringInterface

  Proxy of C++ Ogre::ExternalTextureSource class


*/
swig_class SwigClassExternalTextureSource;

SWIGINTERN void
free_Ogre_ExternalTextureSource(Ogre::ExternalTextureSource *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ExternalTextureSource.set_input_name

  call-seq:
    set_input_name(String sIN)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_set_input_name(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;
  }
  {
    try {
      (arg1)->setInputName(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.get_input_name

  call-seq:
    get_input_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_get_input_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ExternalTextureSource const *)arg1)->getInputName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.set_fps

  call-seq:
    set_fps(int iFPS)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_set_fps(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);
  {
    try {
      (arg1)->setFPS(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.get_fps

  call-seq:
    get_fps -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_get_fps(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);
  {
    try {
      result = (int)((Ogre::ExternalTextureSource const *)arg1)->getFPS();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.set_play_mode

  call-seq:
    set_play_mode(eTexturePlayMode eMode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_set_play_mode(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);
  {
    try {
      (arg1)->setPlayMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.get_play_mode

  call-seq:
    get_play_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_get_play_mode(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);
  {
    try {
      result = (Ogre::eTexturePlayMode)((Ogre::ExternalTextureSource const *)arg1)->getPlayMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.set_texture_tec_pass_state_level

  call-seq:
    set_texture_tec_pass_state_level(int t, int p, int s)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_set_texture_tec_pass_state_level(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);
  {
    try {
      (arg1)->setTextureTecPassStateLevel(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.get_texture_tec_pass_state_level

  call-seq:
    get_texture_tec_pass_state_level(int t, int p, int s)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_get_texture_tec_pass_state_level(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);
  {
    try {
      ((Ogre::ExternalTextureSource const *)arg1)->getTextureTecPassStateLevel(*arg2,*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.add_base_params

  call-seq:
    add_base_params

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_add_base_params(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);
  {
    try {
      (arg1)->addBaseParams();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.get_plugin_string_name

  call-seq:
    get_plugin_string_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_get_plugin_string_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ExternalTextureSource const *)arg1)->getPluginStringName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.get_dictionary_string_name

  call-seq:
    get_dictionary_string_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_get_dictionary_string_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ExternalTextureSource const *)arg1)->getDictionaryStringName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.initialise

  call-seq:
    initialise -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)(arg1)->initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.shut_down

  call-seq:
    shut_down

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_shut_down(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);
  {
    try {
      (arg1)->shutDown();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.create_defined_texture

  call-seq:
    create_defined_texture(String sMaterialName, String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    create_defined_texture(String sMaterialName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_create_defined_texture__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;
  }
  {
    try {
      (arg1)->createDefinedTexture((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_create_defined_texture__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;
  }
  {
    try {
      (arg1)->createDefinedTexture((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ExternalTextureSource_create_defined_texture(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_create_defined_texture__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_create_defined_texture__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ExternalTextureSource.create_defined_texture", 
    "    void ExternalTextureSource.create_defined_texture(Ogre::String const &sMaterialName, Ogre::String const &groupName)\n"
    "    void ExternalTextureSource.create_defined_texture(Ogre::String const &sMaterialName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSource.destroy_advanced_texture

  call-seq:
    destroy_advanced_texture(String sTextureName, String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    destroy_advanced_texture(String sTextureName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSource_destroy_advanced_texture__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;
  }
  {
    try {
      (arg1)->destroyAdvancedTexture((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_destroy_advanced_texture__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;
  }
  {
    try {
      (arg1)->destroyAdvancedTexture((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ExternalTextureSource_destroy_advanced_texture(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_destroy_advanced_texture__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_destroy_advanced_texture__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ExternalTextureSource.destroy_advanced_texture", 
    "    void ExternalTextureSource.destroy_advanced_texture(Ogre::String const &sTextureName, Ogre::String const &groupName)\n"
    "    void ExternalTextureSource.destroy_advanced_texture(Ogre::String const &sTextureName)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::ExternalTextureSourceManager

  Proxy of C++ Ogre::ExternalTextureSourceManager class


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


/*
  Document-method: Ogre::ExternalTextureSourceManager.new

  call-seq:
    ExternalTextureSourceManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ExternalTextureSourceManager *)new Ogre::ExternalTextureSourceManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ExternalTextureSourceManager(Ogre::ExternalTextureSourceManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ExternalTextureSourceManager.set_current_plug_in

  call-seq:
    set_current_plug_in(String sTexturePlugInType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_set_current_plug_in(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;
  }
  {
    try {
      (arg1)->setCurrentPlugIn((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSourceManager.get_current_plug_in

  call-seq:
    get_current_plug_in -> ExternalTextureSource

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_get_current_plug_in(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);
  {
    try {
      result = (Ogre::ExternalTextureSource *)((Ogre::ExternalTextureSourceManager const *)arg1)->getCurrentPlugIn();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ExternalTextureSource, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSourceManager.destroy_advanced_texture

  call-seq:
    destroy_advanced_texture(String sTextureName, String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    destroy_advanced_texture(String sTextureName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_destroy_advanced_texture__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;
  }
  {
    try {
      (arg1)->destroyAdvancedTexture((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_destroy_advanced_texture__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;
  }
  {
    try {
      (arg1)->destroyAdvancedTexture((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ExternalTextureSourceManager_destroy_advanced_texture(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_destroy_advanced_texture__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_destroy_advanced_texture__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ExternalTextureSourceManager.destroy_advanced_texture", 
    "    void ExternalTextureSourceManager.destroy_advanced_texture(Ogre::String const &sTextureName, Ogre::String const &groupName)\n"
    "    void ExternalTextureSourceManager.destroy_advanced_texture(Ogre::String const &sTextureName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSourceManager.get_external_texture_source

  call-seq:
    get_external_texture_source(String sTexturePlugInType) -> ExternalTextureSource

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_get_external_texture_source(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;
  }
  {
    try {
      result = (Ogre::ExternalTextureSource *)(arg1)->getExternalTextureSource((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ExternalTextureSource, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSourceManager.set_external_texture_source

  call-seq:
    set_external_texture_source(String sTexturePlugInType, ExternalTextureSource pTextureSystem)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_set_external_texture_source(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);
  {
    try {
      (arg1)->setExternalTextureSource((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSourceManager.get_singleton

  call-seq:
    get_singleton -> ExternalTextureSourceManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::ExternalTextureSourceManager *) &Ogre::ExternalTextureSourceManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ExternalTextureSourceManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ExternalTextureSourceManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> ExternalTextureSourceManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::ExternalTextureSourceManager *)Ogre::ExternalTextureSourceManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ExternalTextureSourceManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::FileSystemArchive < Ogre::Ogre::Archive

  Proxy of C++ Ogre::FileSystemArchive class


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


/*
  Document-method: Ogre::FileSystemArchive.new

  call-seq:
    FileSystemArchive.new(String name, String archType)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::FileSystemArchive *)new Ogre::FileSystemArchive((Ogre::String const &)*arg1,(Ogre::String const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::FileSystemArchive.is_case_sensitive

  call-seq:
    is_case_sensitive -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_FileSystemArchive_is_case_sensitive(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);
  {
    try {
      result = (bool)((Ogre::FileSystemArchive const *)arg1)->isCaseSensitive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileSystemArchive.load

  call-seq:
    load

An instance method.

*/
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);
  {
    try {
      (arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileSystemArchive.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileSystemArchive.open

  call-seq:
    open(String filename, bool readOnly=true) -> DataStreamPtr
    open(String filename) -> DataStreamPtr

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::FileSystemArchive const *)arg1)->open((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
  }
  {
    try {
      result = ((Ogre::FileSystemArchive const *)arg1)->open((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::FileSystemArchive.create

  call-seq:
    create(String filename) -> DataStreamPtr

An instance method.

*/
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;
  }
  {
    try {
      result = ((Ogre::FileSystemArchive const *)arg1)->create((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::FileSystemArchive.remove

  call-seq:
    remove(String filename)

An instance method.

*/
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;
  }
  {
    try {
      ((Ogre::FileSystemArchive const *)arg1)->remove((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::FileSystemArchive.list

  call-seq:
    list(bool recursive=true, bool dirs=false) -> StringVectorPtr
    list(bool recursive=true) -> StringVectorPtr
    list -> StringVectorPtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->list(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->list(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->list();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::FileSystemArchive.list_file_info

  call-seq:
    list_file_info(bool recursive=true, bool dirs=false) -> FileInfoListPtr
    list_file_info(bool recursive=true) -> FileInfoListPtr
    list_file_info -> FileInfoListPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_FileSystemArchive_list_file_info__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);
  {
    try {
      result = (arg1)->listFileInfo(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_list_file_info__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);
  {
    try {
      result = (arg1)->listFileInfo(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_list_file_info__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);
  {
    try {
      result = (arg1)->listFileInfo();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_list_file_info(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_file_info__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_file_info__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_file_info__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FileSystemArchive.list_file_info", 
    "    Ogre::FileInfoListPtr FileSystemArchive.list_file_info(bool recursive, bool dirs)\n"
    "    Ogre::FileInfoListPtr FileSystemArchive.list_file_info(bool recursive)\n"
    "    Ogre::FileInfoListPtr FileSystemArchive.list_file_info()\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);
  {
    try {
      result = (arg1)->find((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = (arg1)->find((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
  }
  {
    try {
      result = (arg1)->find((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::FileSystemArchive.find_file_info

  call-seq:
    find_file_info(String pattern, bool recursive=true, bool dirs=false) -> FileInfoListPtr
    find_file_info(String pattern, bool recursive=true) -> FileInfoListPtr
    find_file_info(String pattern) -> FileInfoListPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_FileSystemArchive_find_file_info__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);
  {
    try {
      result = ((Ogre::FileSystemArchive const *)arg1)->findFileInfo((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_find_file_info__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);
  {
    try {
      result = ((Ogre::FileSystemArchive const *)arg1)->findFileInfo((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_find_file_info__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;
  }
  {
    try {
      result = ((Ogre::FileSystemArchive const *)arg1)->findFileInfo((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_find_file_info(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_file_info__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_file_info__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_file_info__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FileSystemArchive.find_file_info", 
    "    Ogre::FileInfoListPtr FileSystemArchive.find_file_info(Ogre::String const &pattern, bool recursive, bool dirs)\n"
    "    Ogre::FileInfoListPtr FileSystemArchive.find_file_info(Ogre::String const &pattern, bool recursive)\n"
    "    Ogre::FileInfoListPtr FileSystemArchive.find_file_info(Ogre::String const &pattern)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::FileSystemArchive.exists

  call-seq:
    exists(String filename) -> bool

An instance method.

*/
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;
  }
  {
    try {
      result = (bool)(arg1)->exists((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::FileSystemArchive.get_modified_time

  call-seq:
    get_modified_time(String filename) -> time_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_FileSystemArchive_get_modified_time(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;
  }
  {
    try {
      result = (arg1)->getModifiedTime((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
}



/*
  Document-method: Ogre::FileSystemArchive.set_ignore_hidden

  call-seq:
    set_ignore_hidden(bool ignore)

A class method.

*/
SWIGINTERN VALUE
_wrap_FileSystemArchive_set_ignore_hidden(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);
  {
    try {
      Ogre::FileSystemArchive::setIgnoreHidden(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileSystemArchive.get_ignore_hidden

  call-seq:
    get_ignore_hidden -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_FileSystemArchive_get_ignore_hidden(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;
  }
  {
    try {
      result = (bool)Ogre::FileSystemArchive::getIgnoreHidden();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileSystemArchive.msIgnoreHidden

  call-seq:
    msIgnoreHidden -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::FileSystemArchive.msIgnoreHidden=

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

Set new value for attribute.

*/

/*
  Document-method: Ogre::FileSystemArchive.FileSystemArchive_msIgnoreHidden

  call-seq:
    FileSystemArchive_msIgnoreHidden -> bool

Get value of attribute.

*/
SWIGINTERN VALUE
_wrap_FileSystemArchive_msIgnoreHidden_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_bool(static_cast< bool >(Ogre::FileSystemArchive::msIgnoreHidden));
  return _val;
}



/*
  Document-method: Ogre::FileSystemArchive.FileSystemArchive_msIgnoreHidden=

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

Set new value for attribute.

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



/*
  Document-class: Ogre::FileSystemArchiveFactory < Ogre::Ogre::ArchiveFactory

  Proxy of C++ Ogre::FileSystemArchiveFactory class


*/
swig_class SwigClassFileSystemArchiveFactory;

SWIGINTERN void
free_Ogre_FileSystemArchiveFactory(Ogre::FileSystemArchiveFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::FileSystemArchiveFactory.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_FileSystemArchiveFactory_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::FileSystemArchiveFactory const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FileSystemArchiveFactory.create_instance

  call-seq:
    create_instance(String name) -> Archive

An instance method.

*/
SWIGINTERN VALUE
_wrap_FileSystemArchiveFactory_create_instance(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;
  }
  {
    try {
      result = (Ogre::Archive *)(arg1)->createInstance((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Archive, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::FileSystemArchiveFactory.destroy_instance

  call-seq:
    destroy_instance(Archive arch)

An instance method.

*/
SWIGINTERN VALUE
_wrap_FileSystemArchiveFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::FileSystemArchiveFactory.new

  call-seq:
    FileSystemArchiveFactory.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::FileSystemArchiveFactory *)new Ogre::FileSystemArchiveFactory();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Font < Ogre::Ogre::Resource, Ogre::Ogre::ManualResourceLoader

  Proxy of C++ Ogre::Font class


*/
swig_class SwigClassFont;


/*
  Document-method: Ogre::Font.new

  call-seq:
    Font.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual=false, 
    ManualResourceLoader loader=0)
    Font.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual=false)
    Font.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Font *)new Ogre::Font(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::Font *)new Ogre::Font(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Font *)new Ogre::Font(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::Font.set_type

  call-seq:
    set_type(FontType ftype)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_set_type(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);
  {
    try {
      (arg1)->setType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.get_type

  call-seq:
    get_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_get_type(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);
  {
    try {
      result = (Ogre::FontType)((Ogre::Font const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.set_source

  call-seq:
    set_source(String source)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_set_source(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;
  }
  {
    try {
      (arg1)->setSource((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Font.get_source

  call-seq:
    get_source -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_get_source(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Font const *)arg1)->getSource();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.set_character_spacer

  call-seq:
    set_character_spacer(uint charSpacer)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_set_character_spacer(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);
  {
    try {
      (arg1)->setCharacterSpacer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.get_character_spacer

  call-seq:
    get_character_spacer -> uint

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_get_character_spacer(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);
  {
    try {
      result = (Ogre::uint)((Ogre::Font const *)arg1)->getCharacterSpacer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.set_true_type_size

  call-seq:
    set_true_type_size(Real ttfSize)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_set_true_type_size(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);
  {
    try {
      (arg1)->setTrueTypeSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.set_true_type_resolution

  call-seq:
    set_true_type_resolution(uint ttfResolution)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_set_true_type_resolution(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);
  {
    try {
      (arg1)->setTrueTypeResolution(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.get_true_type_size

  call-seq:
    get_true_type_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_get_true_type_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Font const *)arg1)->getTrueTypeSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.get_true_type_resolution

  call-seq:
    get_true_type_resolution -> uint

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_get_true_type_resolution(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);
  {
    try {
      result = (Ogre::uint)((Ogre::Font const *)arg1)->getTrueTypeResolution();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.get_true_type_max_bearing_y

  call-seq:
    get_true_type_max_bearing_y -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_get_true_type_max_bearing_y(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);
  {
    try {
      result = (int)((Ogre::Font const *)arg1)->getTrueTypeMaxBearingY();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.get_glyph_tex_coords

  call-seq:
    get_glyph_tex_coords(CodePoint id) -> UVRect

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_get_glyph_tex_coords(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);
  {
    try {
      result = (Ogre::Font::UVRect *) &((Ogre::Font const *)arg1)->getGlyphTexCoords(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TRectT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.set_glyph_tex_coords

  call-seq:
    set_glyph_tex_coords(CodePoint id, Real u1, Real v1, Real u2, Real v2, Real textureAspect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_set_glyph_tex_coords(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);
  {
    try {
      (arg1)->setGlyphTexCoords(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.get_glyph_aspect_ratio

  call-seq:
    get_glyph_aspect_ratio(CodePoint id) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_get_glyph_aspect_ratio(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Font const *)arg1)->getGlyphAspectRatio(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.set_glyph_aspect_ratio

  call-seq:
    set_glyph_aspect_ratio(CodePoint id, Real ratio)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_set_glyph_aspect_ratio(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);
  {
    try {
      (arg1)->setGlyphAspectRatio(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.get_glyph_info

  call-seq:
    get_glyph_info(CodePoint id) -> GlyphInfo

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_get_glyph_info(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);
  {
    try {
      result = (Ogre::Font::GlyphInfo *) &((Ogre::Font const *)arg1)->getGlyphInfo(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Font__GlyphInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.add_code_point_range

  call-seq:
    add_code_point_range(CodePointRange range)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_add_code_point_range(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);
  {
    try {
      (arg1)->addCodePointRange((Ogre::Font::CodePointRange const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.clear_code_point_ranges

  call-seq:
    clear_code_point_ranges

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_clear_code_point_ranges(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);
  {
    try {
      (arg1)->clearCodePointRanges();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.get_code_point_range_list

  call-seq:
    get_code_point_range_list -> CodePointRangeList

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_get_code_point_range_list(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);
  {
    try {
      result = (Ogre::Font::CodePointRangeList *) &((Ogre::Font const *)arg1)->getCodePointRangeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Font__CodePointRange_Ogre__STLAllocatorT_Ogre__Font__CodePointRange_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.get_material

  call-seq:
    get_material -> MaterialPtr
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_get_material__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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::Font const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_get_material__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);
  {
    try {
      result = (Ogre::MaterialPtr *) &(arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Font_get_material(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_get_material__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_get_material__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Font.get_material", 
    "    Ogre::MaterialPtr const & Font.get_material()\n"
    "    Ogre::MaterialPtr const & Font.get_material()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Font.set_antialias_colour

  call-seq:
    set_antialias_colour(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_set_antialias_colour(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);
  {
    try {
      (arg1)->setAntialiasColour(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.get_antialias_colour

  call-seq:
    get_antialias_colour -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_get_antialias_colour(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);
  {
    try {
      result = (bool)((Ogre::Font const *)arg1)->getAntialiasColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Font.load_resource

  call-seq:
    load_resource(Resource resource)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Font_load_resource(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);
  {
    try {
      (arg1)->loadResource(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::FontPtr

  Proxy of C++ Ogre::FontPtr class


*/
swig_class SwigClassFontPtr;


/*
  Document-method: Ogre::FontPtr.new

  call-seq:
    FontPtr.new
    FontPtr.new(Font rep)
    FontPtr.new(FontPtr r)
    FontPtr.new(ResourcePtr r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::FontPtr *)new Ogre::FontPtr();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::FontPtr *)new Ogre::FontPtr(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::FontPtr *)new Ogre::FontPtr((Ogre::FontPtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::FontPtr *)new Ogre::FontPtr((Ogre::ResourcePtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::FontManager < Ogre::Ogre::ResourceManager

  Proxy of C++ Ogre::FontManager class


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


/*
  Document-method: Ogre::FontManager.new

  call-seq:
    FontManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::FontManager *)new Ogre::FontManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FontManager(Ogre::FontManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::FontManager.parse_script

  call-seq:
    parse_script(DataStreamPtr stream, String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_FontManager_parse_script(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;
  }
  {
    try {
      (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::FontManager.get_singleton

  call-seq:
    get_singleton -> FontManager

A class method.

*/
SWIGINTERN VALUE
_wrap_FontManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::FontManager *) &Ogre::FontManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__FontManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FontManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> FontManager

A class method.

*/
SWIGINTERN VALUE
_wrap_FontManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::FontManager *)Ogre::FontManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__FontManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::FreeImageCodec < Ogre::Ogre::ImageCodec

  Proxy of C++ Ogre::FreeImageCodec class


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


/*
  Document-method: Ogre::FreeImageCodec.new

  call-seq:
    FreeImageCodec.new(String type, unsigned int fiType)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::FreeImageCodec *)new Ogre::FreeImageCodec((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::FreeImageCodec.code

  call-seq:
    code(MemoryDataStreamPtr input, CodecDataPtr pData) -> DataStreamPtr

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::FreeImageCodec const *)arg1)->code(*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FreeImageCodec.code_to_file

  call-seq:
    code_to_file(MemoryDataStreamPtr input, String outFileName, CodecDataPtr pData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_FreeImageCodec_code_to_file(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);
  {
    try {
      ((Ogre::FreeImageCodec const *)arg1)->codeToFile(*arg2,(Ogre::String const &)*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::FreeImageCodec.decode

  call-seq:
    decode(DataStreamPtr input) -> DecodeResult

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::FreeImageCodec const *)arg1)->decode(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::FreeImageCodec.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_FreeImageCodec_get_type(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);
  {
    try {
      result = ((Ogre::FreeImageCodec const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FreeImageCodec.magic_number_to_file_ext

  call-seq:
    magic_number_to_file_ext(char magicNumberPtr, size_t maxbytes) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_FreeImageCodec_magic_number_to_file_ext(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);
  {
    try {
      result = ((Ogre::FreeImageCodec const *)arg1)->magicNumberToFileExt((char const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::FreeImageCodec.startup

  call-seq:
    startup

A class method.

*/
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;
  }
  {
    try {
      Ogre::FreeImageCodec::startup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FreeImageCodec.shutdown

  call-seq:
    shutdown

A class method.

*/
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;
  }
  {
    try {
      Ogre::FreeImageCodec::shutdown();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::GpuProgramManager < Ogre::Ogre::ResourceManager

  Proxy of C++ Ogre::GpuProgramManager class


*/
swig_class SwigClassGpuProgramManager;

SWIGINTERN void
free_Ogre_GpuProgramManager(Ogre::GpuProgramManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::GpuProgramManager.load

  call-seq:
    load(String name, String groupName, String filename, GpuProgramType gptype, 
    String syntaxCode) -> GpuProgramPtr

An instance method.

*/
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;
  }
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,(Ogre::String const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::GpuProgramManager.load_from_string

  call-seq:
    load_from_string(String name, String groupName, String code, GpuProgramType gptype, 
    String syntaxCode) -> GpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_load_from_string(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;
  }
  {
    try {
      result = (arg1)->loadFromString((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,(Ogre::String const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::GpuProgramManager.get_supported_syntax

  call-seq:
    get_supported_syntax -> SyntaxCodes

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_get_supported_syntax(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);
  {
    try {
      result = (Ogre::GpuProgramManager::SyntaxCodes *) &((Ogre::GpuProgramManager const *)arg1)->getSupportedSyntax();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__setT_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.is_syntax_supported

  call-seq:
    is_syntax_supported(String syntaxCode) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_is_syntax_supported(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;
  }
  {
    try {
      result = (bool)((Ogre::GpuProgramManager const *)arg1)->isSyntaxSupported((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.create_parameters

  call-seq:
    create_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_create_parameters(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);
  {
    try {
      result = (arg1)->createParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.create_program

  call-seq:
    create_program(String name, String groupName, String filename, GpuProgramType gptype, 
    String syntaxCode) -> GpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_create_program(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;
  }
  {
    try {
      result = (arg1)->createProgram((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,(Ogre::String const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::GpuProgramManager.create_program_from_string

  call-seq:
    create_program_from_string(String name, String groupName, String code, GpuProgramType gptype, 
    String syntaxCode) -> GpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_create_program_from_string(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;
  }
  {
    try {
      result = (arg1)->createProgramFromString((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,(Ogre::String const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::GpuProgramManager.create

  call-seq:
    create(String name, String group, GpuProgramType gptype, String syntaxCode, 
    bool isManual=false, ManualResourceLoader loader=0) -> ResourcePtr
    create(String name, String group, GpuProgramType gptype, String syntaxCode, 
    bool isManual=false) -> ResourcePtr
    create(String name, String group, GpuProgramType gptype, String syntaxCode) -> ResourcePtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
  }
  {
    try {
      result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
}



/*
  Document-method: Ogre::GpuProgramManager.get_by_name

  call-seq:
    get_by_name(String name, bool preferHighLevelPrograms=true) -> ResourcePtr
    get_by_name(String name) -> ResourcePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_get_by_name__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);
  {
    try {
      result = (arg1)->getByName((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_get_by_name__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;
  }
  {
    try {
      result = (arg1)->getByName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_by_name(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_get_by_name__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_get_by_name__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "GpuProgramManager.get_by_name", 
    "    Ogre::ResourcePtr GpuProgramManager.get_by_name(Ogre::String const &name, bool preferHighLevelPrograms)\n"
    "    Ogre::ResourcePtr GpuProgramManager.get_by_name(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.create_shared_parameters

  call-seq:
    create_shared_parameters(String name) -> GpuSharedParametersPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_create_shared_parameters(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;
  }
  {
    try {
      result = (arg1)->createSharedParameters((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::GpuProgramManager.get_shared_parameters

  call-seq:
    get_shared_parameters(String name) -> GpuSharedParametersPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_get_shared_parameters(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;
  }
  {
    try {
      result = ((Ogre::GpuProgramManager const *)arg1)->getSharedParameters((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::GpuProgramManager.get_available_shared_parameters

  call-seq:
    get_available_shared_parameters -> SharedParametersMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_get_available_shared_parameters(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);
  {
    try {
      result = (Ogre::GpuProgramManager::SharedParametersMap *) &((Ogre::GpuProgramManager const *)arg1)->getAvailableSharedParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::GpuProgramManager.get_save_microcodes_to_cache

  call-seq:
    get_save_microcodes_to_cache -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_get_save_microcodes_to_cache(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);
  {
    try {
      result = (bool)(arg1)->getSaveMicrocodesToCache();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.set_save_microcodes_to_cache

  call-seq:
    set_save_microcodes_to_cache(bool val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_set_save_microcodes_to_cache(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);
  {
    try {
      (arg1)->setSaveMicrocodesToCache(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.can_get_compiled_shader_buffer

  call-seq:
    can_get_compiled_shader_buffer -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_can_get_compiled_shader_buffer(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);
  {
    try {
      result = (bool)(arg1)->canGetCompiledShaderBuffer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.is_microcode_available_in_cache

  call-seq:
    is_microcode_available_in_cache(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_is_microcode_available_in_cache(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;
  }
  {
    try {
      result = (bool)((Ogre::GpuProgramManager const *)arg1)->isMicrocodeAvailableInCache((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.get_microcode_from_cache

  call-seq:
    get_microcode_from_cache(String name) -> Microcode

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_get_microcode_from_cache(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;
  }
  {
    try {
      result = (Ogre::GpuProgramManager::Microcode *) &((Ogre::GpuProgramManager const *)arg1)->getMicrocodeFromCache((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.create_microcode

  call-seq:
    create_microcode(size_t size) -> Microcode

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_create_microcode(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);
  {
    try {
      result = ((Ogre::GpuProgramManager const *)arg1)->createMicrocode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::GpuProgramManager.add_microcode_to_cache

  call-seq:
    add_microcode_to_cache(String name, Microcode microcode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_add_microcode_to_cache(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);
  {
    try {
      (arg1)->addMicrocodeToCache((Ogre::String const &)*arg2,(Ogre::GpuProgramManager::Microcode const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.save_microcode_cache

  call-seq:
    save_microcode_cache(DataStreamPtr stream)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_save_microcode_cache(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));
    }
  }
  {
    try {
      ((Ogre::GpuProgramManager const *)arg1)->saveMicrocodeCache(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.load_microcode_cache

  call-seq:
    load_microcode_cache(DataStreamPtr stream)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_load_microcode_cache(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));
    }
  }
  {
    try {
      (arg1)->loadMicrocodeCache(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.get_singleton

  call-seq:
    get_singleton -> GpuProgramManager

A class method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::GpuProgramManager *) &Ogre::GpuProgramManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> GpuProgramManager

A class method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::GpuProgramManager *)Ogre::GpuProgramManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::GpuProgramUsage

  Proxy of C++ Ogre::GpuProgramUsage class


*/
swig_class SwigClassGpuProgramUsage;


/*
  Document-method: Ogre::GpuProgramUsage.new

  call-seq:
    GpuProgramUsage.new(GpuProgramType gptype, Pass parent)
    GpuProgramUsage.new(GpuProgramUsage rhs, Pass newparent)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::GpuProgramUsage *)new Ogre::GpuProgramUsage(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::GpuProgramUsage *)new Ogre::GpuProgramUsage((Ogre::GpuProgramUsage const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::GpuProgramUsage.get_type

  call-seq:
    get_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramUsage_get_type(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);
  {
    try {
      result = (Ogre::GpuProgramType)((Ogre::GpuProgramUsage const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramUsage.set_program_name

  call-seq:
    set_program_name(String name, bool resetParams=true)
    set_program_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramUsage_set_program_name__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);
  {
    try {
      (arg1)->setProgramName((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramUsage_set_program_name__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;
  }
  {
    try {
      (arg1)->setProgramName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramUsage_set_program_name(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_set_program_name__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_set_program_name__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "GpuProgramUsage.set_program_name", 
    "    void GpuProgramUsage.set_program_name(Ogre::String const &name, bool resetParams)\n"
    "    void GpuProgramUsage.set_program_name(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramUsage.set_program

  call-seq:
    set_program(GpuProgramPtr prog)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramUsage_set_program(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);
  {
    try {
      (arg1)->setProgram(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramUsage.get_program

  call-seq:
    get_program -> GpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramUsage_get_program(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);
  {
    try {
      result = (Ogre::GpuProgramPtr *) &((Ogre::GpuProgramUsage const *)arg1)->getProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramUsage.get_program_name

  call-seq:
    get_program_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramUsage_get_program_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::GpuProgramUsage const *)arg1)->getProgramName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramUsage.set_parameters

  call-seq:
    set_parameters(GpuProgramParametersSharedPtr params)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramUsage_set_parameters(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));
    }
  }
  {
    try {
      (arg1)->setParameters(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramUsage.get_parameters

  call-seq:
    get_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramUsage_get_parameters(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);
  {
    try {
      result = (arg1)->getParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramUsage._load

  call-seq:
    _load

An instance method.

*/
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);
  {
    try {
      (arg1)->_load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramUsage._unload

  call-seq:
    _unload

An instance method.

*/
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);
  {
    try {
      (arg1)->_unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramUsage.unloading_complete

  call-seq:
    unloading_complete(Resource prog)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramUsage_unloading_complete(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);
  {
    try {
      (arg1)->unloadingComplete(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramUsage.loading_complete

  call-seq:
    loading_complete(Resource prog)

An instance method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramUsage_loading_complete(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);
  {
    try {
      (arg1)->loadingComplete(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::HardwareOcclusionQuery

  Proxy of C++ Ogre::HardwareOcclusionQuery class


*/
swig_class SwigClassHardwareOcclusionQuery;

SWIGINTERN void
free_Ogre_HardwareOcclusionQuery(Ogre::HardwareOcclusionQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::HardwareOcclusionQuery.begin_occlusion_query

  call-seq:
    begin_occlusion_query

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareOcclusionQuery_begin_occlusion_query(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);
  {
    try {
      (arg1)->beginOcclusionQuery();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareOcclusionQuery.end_occlusion_query

  call-seq:
    end_occlusion_query

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareOcclusionQuery_end_occlusion_query(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);
  {
    try {
      (arg1)->endOcclusionQuery();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareOcclusionQuery.pull_occlusion_query

  call-seq:
    pull_occlusion_query(unsigned int NumOfFragments) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareOcclusionQuery_pull_occlusion_query(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);
  {
    try {
      result = (bool)(arg1)->pullOcclusionQuery(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareOcclusionQuery.get_last_querys_pixelcount

  call-seq:
    get_last_querys_pixelcount -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareOcclusionQuery_get_last_querys_pixelcount(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);
  {
    try {
      result = (unsigned int)((Ogre::HardwareOcclusionQuery const *)arg1)->getLastQuerysPixelcount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwareOcclusionQuery.is_still_outstanding

  call-seq:
    is_still_outstanding -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwareOcclusionQuery_is_still_outstanding(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);
  {
    try {
      result = (bool)(arg1)->isStillOutstanding();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::HardwarePixelBuffer < Ogre::Ogre::HardwareBuffer

  Proxy of C++ Ogre::HardwarePixelBuffer class


*/
swig_class SwigClassHardwarePixelBuffer;

SWIGINTERN void
free_Ogre_HardwarePixelBuffer(Ogre::HardwarePixelBuffer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::HardwarePixelBuffer.lock

  call-seq:
    lock(size_t offset, size_t length, LockOptions options) -> void
    lock(LockOptions options)
    lock(Box lockBox, LockOptions options) -> PixelBox
    lock(size_t offset, size_t length, LockOptions options)

An instance method.

*/
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);
  {
    try {
      result = (void *)(arg1)->lock(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (void *)(arg1)->lock(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::PixelBox *) &(arg1)->lock((Ogre::Image::Box const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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);
  {
    try {
      result = (void *)(arg1)->lock(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
}



/*
  Document-method: Ogre::HardwarePixelBuffer.get_current_lock

  call-seq:
    get_current_lock -> PixelBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_get_current_lock(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);
  {
    try {
      result = (Ogre::PixelBox *) &(arg1)->getCurrentLock();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PixelBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwarePixelBuffer.read_data

  call-seq:
    read_data(size_t offset, size_t length, void pDest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_read_data(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] )); 
  }
  {
    try {
      (arg1)->readData(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwarePixelBuffer.write_data

  call-seq:
    write_data(size_t offset, size_t length, void pSource, bool discardWholeBuffer=false)
    write_data(size_t offset, size_t length, void pSource)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_write_data__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);
  {
    try {
      (arg1)->writeData(arg2,arg3,(void const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_write_data__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] )); 
  }
  {
    try {
      (arg1)->writeData(arg2,arg3,(void const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwarePixelBuffer_write_data(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_write_data__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_write_data__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwarePixelBuffer.write_data", 
    "    void HardwarePixelBuffer.write_data(size_t offset, size_t length, void const *pSource, bool discardWholeBuffer)\n"
    "    void HardwarePixelBuffer.write_data(size_t offset, size_t length, void const *pSource)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwarePixelBuffer.blit

  call-seq:
    blit(HardwarePixelBufferSharedPtr src, Box srcBox, Box dstBox)
    blit(HardwarePixelBufferSharedPtr src)

An instance method.

*/
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);
  {
    try {
      (arg1)->blit((Ogre::HardwarePixelBufferSharedPtr const &)*arg2,(Ogre::Image::Box const &)*arg3,(Ogre::Image::Box const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->blit((Ogre::HardwarePixelBufferSharedPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::HardwarePixelBuffer.blit_from_memory

  call-seq:
    blit_from_memory(PixelBox src, Box dstBox)
    blit_from_memory(PixelBox src)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_blit_from_memory__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);
  {
    try {
      (arg1)->blitFromMemory((Ogre::PixelBox const &)*arg2,(Ogre::Image::Box const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_blit_from_memory__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);
  {
    try {
      (arg1)->blitFromMemory((Ogre::PixelBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwarePixelBuffer_blit_from_memory(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_blit_from_memory__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_blit_from_memory__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "HardwarePixelBuffer.blit_from_memory", 
    "    void HardwarePixelBuffer.blit_from_memory(Ogre::PixelBox const &src, Ogre::Image::Box const &dstBox)\n"
    "    void HardwarePixelBuffer.blit_from_memory(Ogre::PixelBox const &src)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwarePixelBuffer.blit_to_memory

  call-seq:
    blit_to_memory(Box srcBox, PixelBox dst)
    blit_to_memory(PixelBox dst)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_blit_to_memory__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);
  {
    try {
      (arg1)->blitToMemory((Ogre::Image::Box const &)*arg2,(Ogre::PixelBox const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_blit_to_memory__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);
  {
    try {
      (arg1)->blitToMemory((Ogre::PixelBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwarePixelBuffer_blit_to_memory(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_blit_to_memory__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_blit_to_memory__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "HardwarePixelBuffer.blit_to_memory", 
    "    void HardwarePixelBuffer.blit_to_memory(Ogre::Image::Box const &srcBox, Ogre::PixelBox const &dst)\n"
    "    void HardwarePixelBuffer.blit_to_memory(Ogre::PixelBox const &dst)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwarePixelBuffer.get_render_target

  call-seq:
    get_render_target(size_t slice=0) -> RenderTexture
    get_render_target -> RenderTexture

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_get_render_target__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);
  {
    try {
      result = (Ogre::RenderTexture *)(arg1)->getRenderTarget(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTexture, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_get_render_target__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);
  {
    try {
      result = (Ogre::RenderTexture *)(arg1)->getRenderTarget();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTexture, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwarePixelBuffer_get_render_target(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_get_render_target__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_get_render_target__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "HardwarePixelBuffer.get_render_target", 
    "    Ogre::RenderTexture * HardwarePixelBuffer.get_render_target(size_t slice)\n"
    "    Ogre::RenderTexture * HardwarePixelBuffer.get_render_target()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::HardwarePixelBuffer.get_width

  call-seq:
    get_width -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_get_width(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);
  {
    try {
      result = ((Ogre::HardwarePixelBuffer const *)arg1)->getWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwarePixelBuffer.get_height

  call-seq:
    get_height -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_get_height(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);
  {
    try {
      result = ((Ogre::HardwarePixelBuffer const *)arg1)->getHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwarePixelBuffer.get_depth

  call-seq:
    get_depth -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_get_depth(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);
  {
    try {
      result = ((Ogre::HardwarePixelBuffer const *)arg1)->getDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HardwarePixelBuffer.get_format

  call-seq:
    get_format -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_get_format(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);
  {
    try {
      result = (Ogre::PixelFormat)((Ogre::HardwarePixelBuffer const *)arg1)->getFormat();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::HardwarePixelBufferSharedPtr

  Proxy of C++ Ogre::HardwarePixelBufferSharedPtr class


*/
swig_class SwigClassHardwarePixelBufferSharedPtr;


/*
  Document-method: Ogre::HardwarePixelBufferSharedPtr.new

  call-seq:
    HardwarePixelBufferSharedPtr.new
    HardwarePixelBufferSharedPtr.new(HardwarePixelBuffer buf)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::HardwarePixelBufferSharedPtr *)new Ogre::HardwarePixelBufferSharedPtr();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::HardwarePixelBufferSharedPtr *)new Ogre::HardwarePixelBufferSharedPtr(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::HighLevelGpuProgram < Ogre::Ogre::GpuProgram

  Proxy of C++ Ogre::HighLevelGpuProgram class


*/
swig_class SwigClassHighLevelGpuProgram;

SWIGINTERN void
free_Ogre_HighLevelGpuProgram(Ogre::HighLevelGpuProgram *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::HighLevelGpuProgram.create_parameters

  call-seq:
    create_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_HighLevelGpuProgram_create_parameters(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);
  {
    try {
      result = (arg1)->createParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HighLevelGpuProgram._get_binding_delegate

  call-seq:
    _get_binding_delegate -> GpuProgram

An instance method.

*/
SWIGINTERN VALUE
_wrap_HighLevelGpuProgram__get_binding_delegate(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);
  {
    try {
      result = (Ogre::GpuProgram *)(arg1)->_getBindingDelegate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgram, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HighLevelGpuProgram.get_constant_definitions

  call-seq:
    get_constant_definitions -> GpuNamedConstants

An instance method.

*/
SWIGINTERN VALUE
_wrap_HighLevelGpuProgram_get_constant_definitions(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);
  {
    try {
      result = (Ogre::GpuNamedConstants *) &((Ogre::HighLevelGpuProgram const *)arg1)->getConstantDefinitions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HighLevelGpuProgram.get_named_constants

  call-seq:
    get_named_constants -> GpuNamedConstants

An instance method.

*/
SWIGINTERN VALUE
_wrap_HighLevelGpuProgram_get_named_constants(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);
  {
    try {
      result = (Ogre::GpuNamedConstants *) &((Ogre::HighLevelGpuProgram const *)arg1)->getNamedConstants();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::HighLevelGpuProgramPtr

  Proxy of C++ Ogre::HighLevelGpuProgramPtr class


*/
swig_class SwigClassHighLevelGpuProgramPtr;


/*
  Document-method: Ogre::HighLevelGpuProgramPtr.new

  call-seq:
    HighLevelGpuProgramPtr.new
    HighLevelGpuProgramPtr.new(HighLevelGpuProgram rep)
    HighLevelGpuProgramPtr.new(HighLevelGpuProgramPtr r)
    HighLevelGpuProgramPtr.new(ResourcePtr r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::HighLevelGpuProgramPtr *)new Ogre::HighLevelGpuProgramPtr();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::HighLevelGpuProgramPtr *)new Ogre::HighLevelGpuProgramPtr(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::HighLevelGpuProgramPtr *)new Ogre::HighLevelGpuProgramPtr((Ogre::HighLevelGpuProgramPtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::HighLevelGpuProgramPtr *)new Ogre::HighLevelGpuProgramPtr((Ogre::ResourcePtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::HighLevelGpuProgramFactory

  Proxy of C++ Ogre::HighLevelGpuProgramFactory class


*/
swig_class SwigClassHighLevelGpuProgramFactory;

SWIGINTERN void
free_Ogre_HighLevelGpuProgramFactory(Ogre::HighLevelGpuProgramFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::HighLevelGpuProgramFactory.get_language

  call-seq:
    get_language -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_HighLevelGpuProgramFactory_get_language(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::HighLevelGpuProgramFactory const *)arg1)->getLanguage();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HighLevelGpuProgramFactory.create

  call-seq:
    create(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual, ManualResourceLoader loader) -> HighLevelGpuProgram

An instance method.

*/
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);
  {
    try {
      result = (Ogre::HighLevelGpuProgram *)(arg1)->create(arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::HighLevelGpuProgramFactory.destroy

  call-seq:
    destroy(HighLevelGpuProgram prog)

An instance method.

*/
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);
  {
    try {
      (arg1)->destroy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::HighLevelGpuProgramManager < Ogre::Ogre::ResourceManager

  Proxy of C++ Ogre::HighLevelGpuProgramManager class


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


/*
  Document-method: Ogre::HighLevelGpuProgramManager.new

  call-seq:
    HighLevelGpuProgramManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::HighLevelGpuProgramManager *)new Ogre::HighLevelGpuProgramManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_HighLevelGpuProgramManager(Ogre::HighLevelGpuProgramManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::HighLevelGpuProgramManager.add_factory

  call-seq:
    add_factory(HighLevelGpuProgramFactory factory)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HighLevelGpuProgramManager_add_factory(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);
  {
    try {
      (arg1)->addFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HighLevelGpuProgramManager.remove_factory

  call-seq:
    remove_factory(HighLevelGpuProgramFactory factory)

An instance method.

*/
SWIGINTERN VALUE
_wrap_HighLevelGpuProgramManager_remove_factory(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);
  {
    try {
      (arg1)->removeFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HighLevelGpuProgramManager.is_language_supported

  call-seq:
    is_language_supported(String lang) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_HighLevelGpuProgramManager_is_language_supported(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;
  }
  {
    try {
      result = (bool)(arg1)->isLanguageSupported((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::HighLevelGpuProgramManager.create_program

  call-seq:
    create_program(String name, String groupName, String language, GpuProgramType gptype) -> HighLevelGpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_HighLevelGpuProgramManager_create_program(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);
  {
    try {
      result = (arg1)->createProgram((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
}



/*
  Document-method: Ogre::HighLevelGpuProgramManager.get_singleton

  call-seq:
    get_singleton -> HighLevelGpuProgramManager

A class method.

*/
SWIGINTERN VALUE
_wrap_HighLevelGpuProgramManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::HighLevelGpuProgramManager *) &Ogre::HighLevelGpuProgramManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HighLevelGpuProgramManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::HighLevelGpuProgramManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> HighLevelGpuProgramManager

A class method.

*/
SWIGINTERN VALUE
_wrap_HighLevelGpuProgramManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::HighLevelGpuProgramManager *)Ogre::HighLevelGpuProgramManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HighLevelGpuProgramManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::InstanceBatch < Ogre::Ogre::Renderable, Ogre::Ogre::MovableObject

  Proxy of C++ Ogre::InstanceBatch class


*/
swig_class SwigClassInstanceBatch;

SWIGINTERN void
free_Ogre_InstanceBatch(Ogre::InstanceBatch *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::InstanceBatch._get_mesh_ref

  call-seq:
    _get_mesh_ref -> MeshPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch__get_mesh_ref(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);
  {
    try {
      result = (Ogre::MeshPtr *) &(arg1)->_getMeshRef();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch._set_instances_per_batch

  call-seq:
    _set_instances_per_batch(size_t instancesPerBatch)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch__set_instances_per_batch(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);
  {
    try {
      (arg1)->_setInstancesPerBatch(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch._get_index_to_bone_map

  call-seq:
    _get_index_to_bone_map -> IndexMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch__get_index_to_bone_map(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);
  {
    try {
      result = (Ogre::Mesh::IndexMap *)((Ogre::InstanceBatch const *)arg1)->_getIndexToBoneMap();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch._supports_skeletal_animation

  call-seq:
    _supports_skeletal_animation -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch__supports_skeletal_animation(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);
  {
    try {
      result = (bool)((Ogre::InstanceBatch const *)arg1)->_supportsSkeletalAnimation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch._update_bounds

  call-seq:
    _update_bounds

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch__update_bounds(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);
  {
    try {
      (arg1)->_updateBounds();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.calculate_max_num_instances

  call-seq:
    calculate_max_num_instances(SubMesh baseSubMesh, uint16 flags) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_calculate_max_num_instances(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);
  {
    try {
      result = ((Ogre::InstanceBatch const *)arg1)->calculateMaxNumInstances((Ogre::SubMesh const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.build

  call-seq:
    build(SubMesh baseSubMesh) -> RenderOperation

An instance method.

*/
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);
  {
    try {
      result = (arg1)->build((Ogre::SubMesh const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::RenderOperation(static_cast< const Ogre::RenderOperation& >(result))), SWIGTYPE_p_Ogre__RenderOperation, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.build_from

  call-seq:
    build_from(SubMesh baseSubMesh, RenderOperation renderOperation)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_build_from(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);
  {
    try {
      (arg1)->buildFrom((Ogre::SubMesh const *)arg2,(Ogre::RenderOperation const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch._get_mesh_reference

  call-seq:
    _get_mesh_reference -> MeshPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch__get_mesh_reference(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);
  {
    try {
      result = (Ogre::MeshPtr *) &((Ogre::InstanceBatch const *)arg1)->_getMeshReference();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.is_batch_full

  call-seq:
    is_batch_full -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_is_batch_full(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);
  {
    try {
      result = (bool)((Ogre::InstanceBatch const *)arg1)->isBatchFull();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.is_batch_unused

  call-seq:
    is_batch_unused -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_is_batch_unused(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);
  {
    try {
      result = (bool)((Ogre::InstanceBatch const *)arg1)->isBatchUnused();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.get_instanced_entities_in_use

  call-seq:
    get_instanced_entities_in_use(InstancedEntityVec outEntities)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_get_instanced_entities_in_use(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);
  {
    try {
      (arg1)->getInstancedEntitiesInUse(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch._defragment_batch

  call-seq:
    _defragment_batch(bool optimizeCulling, InstancedEntityVec usedEntities)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch__defragment_batch(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);
  {
    try {
      (arg1)->_defragmentBatch(arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch._defragment_batch_discard

  call-seq:
    _defragment_batch_discard

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch__defragment_batch_discard(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);
  {
    try {
      (arg1)->_defragmentBatchDiscard();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch._bounds_dirty

  call-seq:
    _bounds_dirty

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch__bounds_dirty(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);
  {
    try {
      (arg1)->_boundsDirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.set_static_and_update

  call-seq:
    set_static_and_update(bool bStatic)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_set_static_and_update(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);
  {
    try {
      (arg1)->setStaticAndUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.is_static

  call-seq:
    is_static -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_is_static(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);
  {
    try {
      result = (bool)((Ogre::InstanceBatch const *)arg1)->isStatic();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.create_instanced_entity

  call-seq:
    create_instanced_entity -> InstancedEntity

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_create_instanced_entity(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);
  {
    try {
      result = (Ogre::InstancedEntity *)(arg1)->createInstancedEntity();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstancedEntity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.remove_instanced_entity

  call-seq:
    remove_instanced_entity(InstancedEntity instancedEntity)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_remove_instanced_entity(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);
  {
    try {
      (arg1)->removeInstancedEntity(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.use_bone_world_matrices

  call-seq:
    use_bone_world_matrices -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_use_bone_world_matrices(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);
  {
    try {
      result = (bool)((Ogre::InstanceBatch const *)arg1)->useBoneWorldMatrices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch._mark_transform_sharing_dirty

  call-seq:
    _mark_transform_sharing_dirty

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch__mark_transform_sharing_dirty(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);
  {
    try {
      (arg1)->_markTransformSharingDirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::InstanceBatch const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.get_render_operation

  call-seq:
    get_render_operation(RenderOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_get_render_operation(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);
  {
    try {
      (arg1)->getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera cam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::InstanceBatch const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.get_lights

  call-seq:
    get_lights -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_get_lights(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::InstanceBatch const *)arg1)->getLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.get_technique

  call-seq:
    get_technique -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_get_technique(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);
  {
    try {
      result = (Ogre::Technique *)((Ogre::InstanceBatch const *)arg1)->getTechnique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::InstanceBatch const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch._notify_current_camera

  call-seq:
    _notify_current_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch__notify_current_camera(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);
  {
    try {
      (arg1)->_notifyCurrentCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::InstanceBatch const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::InstanceBatch const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatch.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatch_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstanceBatch_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstanceBatch.visit_renderables", 
    "    void InstanceBatch.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void InstanceBatch.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::InstanceBatchHW < Ogre::Ogre::InstanceBatch

  Proxy of C++ Ogre::InstanceBatchHW class


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


/*
  Document-method: Ogre::InstanceBatchHW.new

  call-seq:
    InstanceBatchHW.new(InstanceManager creator, MeshPtr meshReference, MaterialPtr material, 
    size_t instancesPerBatch, 
    IndexMap indexToBoneMap, String batchName)

Class constructor.

*/
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;
  }
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::InstanceBatchHW.calculate_max_num_instances

  call-seq:
    calculate_max_num_instances(SubMesh baseSubMesh, uint16 flags) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHW_calculate_max_num_instances(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);
  {
    try {
      result = ((Ogre::InstanceBatchHW const *)arg1)->calculateMaxNumInstances((Ogre::SubMesh const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchHW.build_from

  call-seq:
    build_from(SubMesh baseSubMesh, RenderOperation renderOperation)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHW_build_from(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);
  {
    try {
      (arg1)->buildFrom((Ogre::SubMesh const *)arg2,(Ogre::RenderOperation const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchHW._bounds_dirty

  call-seq:
    _bounds_dirty

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHW__bounds_dirty(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);
  {
    try {
      (arg1)->_boundsDirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchHW.set_static_and_update

  call-seq:
    set_static_and_update(bool bStatic)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHW_set_static_and_update(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);
  {
    try {
      (arg1)->setStaticAndUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchHW.is_static

  call-seq:
    is_static -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHW_is_static(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);
  {
    try {
      result = (bool)((Ogre::InstanceBatchHW const *)arg1)->isStatic();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchHW.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHW_get_world_transforms(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);
  {
    try {
      ((Ogre::InstanceBatchHW const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchHW.get_num_world_transforms

  call-seq:
    get_num_world_transforms -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHW_get_num_world_transforms(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);
  {
    try {
      result = (unsigned short)((Ogre::InstanceBatchHW const *)arg1)->getNumWorldTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchHW._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHW__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::BaseInstanceBatchVTF < Ogre::Ogre::InstanceBatch

  Proxy of C++ Ogre::BaseInstanceBatchVTF class


*/
swig_class SwigClassBaseInstanceBatchVTF;

SWIGINTERN void
free_Ogre_BaseInstanceBatchVTF(Ogre::BaseInstanceBatchVTF *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::BaseInstanceBatchVTF.build_from

  call-seq:
    build_from(SubMesh baseSubMesh, RenderOperation renderOperation)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_build_from(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);
  {
    try {
      (arg1)->buildFrom((Ogre::SubMesh const *)arg2,(Ogre::RenderOperation const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_get_world_transforms(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);
  {
    try {
      ((Ogre::BaseInstanceBatchVTF const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF.get_num_world_transforms

  call-seq:
    get_num_world_transforms -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_get_num_world_transforms(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);
  {
    try {
      result = (unsigned short)((Ogre::BaseInstanceBatchVTF const *)arg1)->getNumWorldTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF.set_bone_matrix_lookup

  call-seq:
    set_bone_matrix_lookup(bool enable, size_t maxLookupTableInstances)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_set_bone_matrix_lookup(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);
  {
    try {
      (arg1)->setBoneMatrixLookup(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF.use_bone_matrix_lookup

  call-seq:
    use_bone_matrix_lookup -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_use_bone_matrix_lookup(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);
  {
    try {
      result = (bool)((Ogre::BaseInstanceBatchVTF const *)arg1)->useBoneMatrixLookup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF.set_bone_dual_quaternions

  call-seq:
    set_bone_dual_quaternions(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_set_bone_dual_quaternions(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);
  {
    try {
      (arg1)->setBoneDualQuaternions(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF.use_bone_dual_quaternions

  call-seq:
    use_bone_dual_quaternions -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_use_bone_dual_quaternions(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);
  {
    try {
      result = (bool)((Ogre::BaseInstanceBatchVTF const *)arg1)->useBoneDualQuaternions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF.set_force_one_weight

  call-seq:
    set_force_one_weight(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_set_force_one_weight(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);
  {
    try {
      (arg1)->setForceOneWeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF.force_one_weight

  call-seq:
    force_one_weight -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_force_one_weight(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);
  {
    try {
      result = (bool)((Ogre::BaseInstanceBatchVTF const *)arg1)->forceOneWeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF.set_use_one_weight

  call-seq:
    set_use_one_weight(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_set_use_one_weight(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);
  {
    try {
      (arg1)->setUseOneWeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF.use_one_weight

  call-seq:
    use_one_weight -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_use_one_weight(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);
  {
    try {
      result = (bool)((Ogre::BaseInstanceBatchVTF const *)arg1)->useOneWeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF.use_bone_world_matrices

  call-seq:
    use_bone_world_matrices -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_use_bone_world_matrices(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);
  {
    try {
      result = (bool)((Ogre::BaseInstanceBatchVTF const *)arg1)->useBoneWorldMatrices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BaseInstanceBatchVTF.get_max_lookup_table_instances

  call-seq:
    get_max_lookup_table_instances -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_get_max_lookup_table_instances(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);
  {
    try {
      result = ((Ogre::BaseInstanceBatchVTF const *)arg1)->getMaxLookupTableInstances();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::InstanceBatchVTF < Ogre::Ogre::BaseInstanceBatchVTF

  Proxy of C++ Ogre::InstanceBatchVTF class


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


/*
  Document-method: Ogre::InstanceBatchVTF.new

  call-seq:
    InstanceBatchVTF.new(InstanceManager creator, MeshPtr meshReference, MaterialPtr material, 
    size_t instancesPerBatch, 
    IndexMap indexToBoneMap, String batchName)

Class constructor.

*/
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;
  }
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::InstanceBatchVTF.calculate_max_num_instances

  call-seq:
    calculate_max_num_instances(SubMesh baseSubMesh, uint16 flags) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchVTF_calculate_max_num_instances(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);
  {
    try {
      result = ((Ogre::InstanceBatchVTF const *)arg1)->calculateMaxNumInstances((Ogre::SubMesh const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::InstanceBatchHWVTF < Ogre::Ogre::BaseInstanceBatchVTF

  Proxy of C++ Ogre::InstanceBatchHWVTF class


*/
swig_class SwigClassInstanceBatchHWVTF;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_InstanceBatchHWVTF_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_InstanceBatchHWVTF_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;
  }
  


/*
  Document-method: Ogre::InstanceBatchHWVTF.new

  call-seq:
    InstanceBatchHWVTF.new(InstanceManager creator, MeshPtr meshReference, MaterialPtr material, 
    size_t instancesPerBatch, 
    IndexMap indexToBoneMap, String batchName)

Class constructor.

*/
SWIGINTERN VALUE
_wrap_new_InstanceBatchHWVTF(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::InstanceBatchHWVTF";
  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;
  }
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::InstanceBatchHWVTF.calculate_max_num_instances

  call-seq:
    calculate_max_num_instances(SubMesh baseSubMesh, uint16 flags) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHWVTF_calculate_max_num_instances(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);
  {
    try {
      result = ((Ogre::InstanceBatchHW_VTF const *)arg1)->calculateMaxNumInstances((Ogre::SubMesh const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchHWVTF._bounds_dirty

  call-seq:
    _bounds_dirty

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHWVTF__bounds_dirty(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);
  {
    try {
      (arg1)->_boundsDirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchHWVTF.set_static_and_update

  call-seq:
    set_static_and_update(bool bStatic)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHWVTF_set_static_and_update(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);
  {
    try {
      (arg1)->setStaticAndUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchHWVTF.is_static

  call-seq:
    is_static -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHWVTF_is_static(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);
  {
    try {
      result = (bool)((Ogre::InstanceBatchHW_VTF const *)arg1)->isStatic();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchHWVTF._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchHWVTF__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::InstanceBatchShader < Ogre::Ogre::InstanceBatch

  Proxy of C++ Ogre::InstanceBatchShader class


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


/*
  Document-method: Ogre::InstanceBatchShader.new

  call-seq:
    InstanceBatchShader.new(InstanceManager creator, MeshPtr meshReference, MaterialPtr material, 
    size_t instancesPerBatch, 
    IndexMap indexToBoneMap, String batchName)

Class constructor.

*/
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;
  }
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::InstanceBatchShader.calculate_max_num_instances

  call-seq:
    calculate_max_num_instances(SubMesh baseSubMesh, uint16 flags) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchShader_calculate_max_num_instances(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);
  {
    try {
      result = ((Ogre::InstanceBatchShader const *)arg1)->calculateMaxNumInstances((Ogre::SubMesh const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchShader.build_from

  call-seq:
    build_from(SubMesh baseSubMesh, RenderOperation renderOperation)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchShader_build_from(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);
  {
    try {
      (arg1)->buildFrom((Ogre::SubMesh const *)arg2,(Ogre::RenderOperation const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchShader.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchShader_get_world_transforms(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);
  {
    try {
      ((Ogre::InstanceBatchShader const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceBatchShader.get_num_world_transforms

  call-seq:
    get_num_world_transforms -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceBatchShader_get_num_world_transforms(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);
  {
    try {
      result = (unsigned short)((Ogre::InstanceBatchShader const *)arg1)->getNumWorldTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::InstanceManager

  Proxy of C++ Ogre::InstanceManager class


*/
swig_class SwigClassInstanceManager;


/*
  Document-method: Ogre::InstancingTechnique.ShaderBased

  call-seq:
    ShaderBased -> int

A class method.

*/

/*
  Document-method: Ogre::InstancingTechnique.TextureVTF

  call-seq:
    TextureVTF -> int

A class method.

*/

/*
  Document-method: Ogre::InstancingTechnique.HWInstancingBasic

  call-seq:
    HWInstancingBasic -> int

A class method.

*/

/*
  Document-method: Ogre::InstancingTechnique.HWInstancingVTF

  call-seq:
    HWInstancingVTF -> int

A class method.

*/

/*
  Document-method: Ogre::InstancingTechnique.InstancingTechniquesCount

  call-seq:
    InstancingTechniquesCount -> int

A class method.

*/

/*
  Document-method: Ogre::BatchSettingId.CAST_SHADOWS

  call-seq:
    CAST_SHADOWS -> int

A class method.

*/

/*
  Document-method: Ogre::BatchSettingId.SHOW_BOUNDINGBOX

  call-seq:
    SHOW_BOUNDINGBOX -> int

A class method.

*/

/*
  Document-method: Ogre::BatchSettingId.NUM_SETTINGS

  call-seq:
    NUM_SETTINGS -> int

A class method.

*/

/*
  Document-method: Ogre::InstanceManager.new

  call-seq:
    InstanceManager.new(String customName, SceneManager sceneManager, String meshName, 
    String groupName, InstancingTechnique instancingTechnique, 
    uint16 instancingFlags, 
    size_t instancesPerBatch, unsigned short subMeshIdx, 
    bool useBoneMatrixLookup=false)
    InstanceManager.new(String customName, SceneManager sceneManager, String meshName, 
    String groupName, InstancingTechnique instancingTechnique, 
    uint16 instancingFlags, 
    size_t instancesPerBatch, unsigned short subMeshIdx)

Class constructor.

*/
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);
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  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);
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  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;
}


/*
  Document-method: Ogre::InstanceManager.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::InstanceManager const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager.set_instances_per_batch

  call-seq:
    set_instances_per_batch(size_t instancesPerBatch)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_set_instances_per_batch(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);
  {
    try {
      (arg1)->setInstancesPerBatch(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager.set_max_lookup_table_instances

  call-seq:
    set_max_lookup_table_instances(size_t maxLookupTableInstances)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_set_max_lookup_table_instances(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);
  {
    try {
      (arg1)->setMaxLookupTableInstances(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager.get_max_or_best_num_instances_per_batch

  call-seq:
    get_max_or_best_num_instances_per_batch(String materialName, size_t suggestedSize, uint16 flags) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_get_max_or_best_num_instances_per_batch(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);
  {
    try {
      result = (arg1)->getMaxOrBestNumInstancesPerBatch(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager.create_instanced_entity

  call-seq:
    create_instanced_entity(String materialName) -> InstancedEntity

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_create_instanced_entity(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;
  }
  {
    try {
      result = (Ogre::InstancedEntity *)(arg1)->createInstancedEntity((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstancedEntity, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager.cleanup_empty_batches

  call-seq:
    cleanup_empty_batches

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_cleanup_empty_batches(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);
  {
    try {
      (arg1)->cleanupEmptyBatches();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager.defragment_batches

  call-seq:
    defragment_batches(bool optimizeCulling)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_defragment_batches(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);
  {
    try {
      (arg1)->defragmentBatches(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager.set_setting

  call-seq:
    set_setting(BatchSettingId id, bool value, String materialName=BLANK)
    set_setting(BatchSettingId id, bool value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_set_setting__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;
  }
  {
    try {
      (arg1)->setSetting(arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_set_setting__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);
  {
    try {
      (arg1)->setSetting(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstanceManager_set_setting(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_set_setting__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_set_setting__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "InstanceManager.set_setting", 
    "    void InstanceManager.set_setting(Ogre::InstanceManager::BatchSettingId id, bool value, Ogre::String const &materialName)\n"
    "    void InstanceManager.set_setting(Ogre::InstanceManager::BatchSettingId id, bool value)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager.get_setting

  call-seq:
    get_setting(BatchSettingId id, String materialName) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_get_setting(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;
  }
  {
    try {
      result = (bool)((Ogre::InstanceManager const *)arg1)->getSetting(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager.has_settings

  call-seq:
    has_settings(String materialName) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_has_settings(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;
  }
  {
    try {
      result = (bool)((Ogre::InstanceManager const *)arg1)->hasSettings((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager.set_batches_as_static_and_update

  call-seq:
    set_batches_as_static_and_update(bool bStatic)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_set_batches_as_static_and_update(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);
  {
    try {
      (arg1)->setBatchesAsStaticAndUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager._add_dirty_batch

  call-seq:
    _add_dirty_batch(InstanceBatch dirtyBatch)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager__add_dirty_batch(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);
  {
    try {
      (arg1)->_addDirtyBatch(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager._update_dirty_batches

  call-seq:
    _update_dirty_batches

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager__update_dirty_batches(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);
  {
    try {
      (arg1)->_updateDirtyBatches();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstanceManager.get_instance_batch_map_iterator

  call-seq:
    get_instance_batch_map_iterator -> InstanceBatchMapIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_get_instance_batch_map_iterator(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);
  {
    try {
      result = ((Ogre::InstanceManager const *)arg1)->getInstanceBatchMapIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::InstanceManager.get_instance_batch_iterator

  call-seq:
    get_instance_batch_iterator(String materialName) -> InstanceBatchIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstanceManager_get_instance_batch_iterator(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;
  }
  {
    try {
      result = ((Ogre::InstanceManager const *)arg1)->getInstanceBatchIterator((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-class: Ogre::InstancedEntity < Ogre::Ogre::MovableObject

  Proxy of C++ Ogre::InstancedEntity class


*/
swig_class SwigClassInstancedEntity;


/*
  Document-method: Ogre::InstancedEntity.new

  call-seq:
    InstancedEntity.new(InstanceBatch batchOwner, uint32 instanceID, InstancedEntity sharedTransformEntity=nil)
    InstancedEntity.new(InstanceBatch batchOwner, uint32 instanceID)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::InstancedEntity *)new Ogre::InstancedEntity(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::InstancedEntity *)new Ogre::InstancedEntity(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::InstancedEntity.share_transform_with

  call-seq:
    share_transform_with(InstancedEntity slave) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_share_transform_with(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);
  {
    try {
      result = (bool)(arg1)->shareTransformWith(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.stop_sharing_transform

  call-seq:
    stop_sharing_transform

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_stop_sharing_transform(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);
  {
    try {
      (arg1)->stopSharingTransform();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity._get_owner

  call-seq:
    _get_owner -> InstanceBatch

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity__get_owner(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);
  {
    try {
      result = (Ogre::InstanceBatch *)((Ogre::InstancedEntity const *)arg1)->_getOwner();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstanceBatch, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::InstancedEntity const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::InstancedEntity const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::InstancedEntity const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera cam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::InstancedEntity const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity._notify_moved

  call-seq:
    _notify_moved

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity__notify_moved(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);
  {
    try {
      (arg1)->_notifyMoved();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity._notify_attached

  call-seq:
    _notify_attached(Node parent, bool isTagPoint=false)
    _notify_attached(Node parent)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedEntity__notify_attached(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__notify_attached__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__notify_attached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstancedEntity._notify_attached", 
    "    void InstancedEntity._notify_attached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void InstancedEntity._notify_attached(Ogre::Node *parent)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedEntity_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstancedEntity.visit_renderables", 
    "    void InstancedEntity.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void InstancedEntity.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.has_skeleton

  call-seq:
    has_skeleton -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_has_skeleton(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);
  {
    try {
      result = (bool)((Ogre::InstancedEntity const *)arg1)->hasSkeleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.get_skeleton

  call-seq:
    get_skeleton -> SkeletonInstance

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_get_skeleton(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);
  {
    try {
      result = (Ogre::SkeletonInstance *)((Ogre::InstancedEntity const *)arg1)->getSkeleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.get_animation_state

  call-seq:
    get_animation_state(String name) -> AnimationState

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_get_animation_state(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;
  }
  {
    try {
      result = (Ogre::AnimationState *)((Ogre::InstancedEntity const *)arg1)->getAnimationState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.get_all_animation_states

  call-seq:
    get_all_animation_states -> AnimationStateSet

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_get_all_animation_states(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);
  {
    try {
      result = (Ogre::AnimationStateSet *)((Ogre::InstancedEntity const *)arg1)->getAllAnimationStates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity._update_animation

  call-seq:
    _update_animation -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity__update_animation(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);
  {
    try {
      result = (bool)(arg1)->_updateAnimation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.set_transform_lookup_number

  call-seq:
    set_transform_lookup_number(uint16 num)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_set_transform_lookup_number(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);
  {
    try {
      (arg1)->setTransformLookupNumber(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.get_position

  call-seq:
    get_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_get_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::InstancedEntity const *)arg1)->getPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.set_position

  call-seq:
    set_position(Vector3 position, bool doUpdate=true)
    set_position(Vector3 position)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_set_position__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);
  {
    try {
      (arg1)->setPosition((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_set_position__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);
  {
    try {
      (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedEntity_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_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_set_position__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_set_position__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstancedEntity.set_position", 
    "    void InstancedEntity.set_position(Ogre::Vector3 const &position, bool doUpdate)\n"
    "    void InstancedEntity.set_position(Ogre::Vector3 const &position)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.get_orientation

  call-seq:
    get_orientation -> Quaternion

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_get_orientation(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);
  {
    try {
      result = (Ogre::Quaternion *) &((Ogre::InstancedEntity const *)arg1)->getOrientation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.set_orientation

  call-seq:
    set_orientation(Quaternion orientation, bool doUpdate=true)
    set_orientation(Quaternion orientation)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_set_orientation__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);
  {
    try {
      (arg1)->setOrientation((Ogre::Quaternion const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_set_orientation__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);
  {
    try {
      (arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedEntity_set_orientation(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_set_orientation__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_set_orientation__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstancedEntity.set_orientation", 
    "    void InstancedEntity.set_orientation(Ogre::Quaternion const &orientation, bool doUpdate)\n"
    "    void InstancedEntity.set_orientation(Ogre::Quaternion const &orientation)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.get_scale

  call-seq:
    get_scale -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_get_scale(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::InstancedEntity const *)arg1)->getScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.set_scale

  call-seq:
    set_scale(Vector3 scale, bool doUpdate=true)
    set_scale(Vector3 scale)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_set_scale__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);
  {
    try {
      (arg1)->setScale((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_set_scale__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);
  {
    try {
      (arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedEntity_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_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_set_scale__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_set_scale__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstancedEntity.set_scale", 
    "    void InstancedEntity.set_scale(Ogre::Vector3 const &scale, bool doUpdate)\n"
    "    void InstancedEntity.set_scale(Ogre::Vector3 const &scale)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.get_max_scale_coef

  call-seq:
    get_max_scale_coef -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_get_max_scale_coef(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);
  {
    try {
      result = (Ogre::Real)((Ogre::InstancedEntity const *)arg1)->getMaxScaleCoef();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.update_transforms

  call-seq:
    update_transforms

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_update_transforms(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);
  {
    try {
      (arg1)->updateTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.is_in_use

  call-seq:
    is_in_use -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_is_in_use(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);
  {
    try {
      result = (bool)((Ogre::InstancedEntity const *)arg1)->isInUse();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.set_in_use

  call-seq:
    set_in_use(bool used)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_set_in_use(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);
  {
    try {
      (arg1)->setInUse(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity._get_parent_node_full_transform

  call-seq:
    _get_parent_node_full_transform -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity__get_parent_node_full_transform(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::InstancedEntity const *)arg1)->_getParentNodeFullTransform();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity._get_derived_position

  call-seq:
    _get_derived_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity__get_derived_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::InstancedEntity const *)arg1)->_getDerivedPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedEntity.is_in_scene

  call-seq:
    is_in_scene -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedEntity_is_in_scene(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);
  {
    try {
      result = (bool)((Ogre::InstancedEntity const *)arg1)->isInScene();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::SimpleRenderable < Ogre::Ogre::MovableObject, Ogre::Ogre::Renderable

  Proxy of C++ Ogre::SimpleRenderable class


*/
swig_class SwigClassSimpleRenderable;


/*
  Document-method: Ogre::SimpleRenderable.set_material

  call-seq:
    set_material(String matName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable_set_material(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;
  }
  {
    try {
      (arg1)->setMaterial((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SimpleRenderable.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::SimpleRenderable const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleRenderable.set_render_operation

  call-seq:
    set_render_operation(RenderOperation rend)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable_set_render_operation(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);
  {
    try {
      (arg1)->setRenderOperation((Ogre::RenderOperation const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleRenderable.get_render_operation

  call-seq:
    get_render_operation(RenderOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable_get_render_operation(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);
  {
    try {
      (arg1)->getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleRenderable.set_world_transform

  call-seq:
    set_world_transform(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable_set_world_transform(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);
  {
    try {
      (arg1)->setWorldTransform((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleRenderable.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable_get_world_transforms(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);
  {
    try {
      ((Ogre::SimpleRenderable const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleRenderable._notify_current_camera

  call-seq:
    _notify_current_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable__notify_current_camera(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);
  {
    try {
      (arg1)->_notifyCurrentCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleRenderable.set_bounding_box

  call-seq:
    set_bounding_box(AxisAlignedBox box)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable_set_bounding_box(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);
  {
    try {
      (arg1)->setBoundingBox((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleRenderable.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::SimpleRenderable const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleRenderable._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleRenderable.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SimpleRenderable_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SimpleRenderable.visit_renderables", 
    "    void SimpleRenderable.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void SimpleRenderable.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_SimpleRenderable(Ogre::SimpleRenderable *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SimpleRenderable.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::SimpleRenderable const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleRenderable.get_lights

  call-seq:
    get_lights -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimpleRenderable_get_lights(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::SimpleRenderable const *)arg1)->getLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::SkeletonInstance < Ogre::Ogre::Skeleton

  Proxy of C++ Ogre::SkeletonInstance class


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


/*
  Document-method: Ogre::SkeletonInstance.new

  call-seq:
    SkeletonInstance.new(SkeletonPtr masterCopy)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::SkeletonInstance *)new Ogre::SkeletonInstance((Ogre::SkeletonPtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SkeletonInstance(Ogre::SkeletonInstance *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SkeletonInstance.get_num_animations

  call-seq:
    get_num_animations -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_get_num_animations(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);
  {
    try {
      result = (unsigned short)((Ogre::SkeletonInstance const *)arg1)->getNumAnimations();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance.get_animation

  call-seq:
    get_animation(unsigned short index) -> Animation
    get_animation(String name, LinkedSkeletonAnimationSource linker=0) -> Animation
    get_animation(String name) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_get_animation__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);
  {
    try {
      result = (Ogre::Animation *)((Ogre::SkeletonInstance const *)arg1)->getAnimation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance._get_animation_impl

  call-seq:
    _get_animation_impl(String name, LinkedSkeletonAnimationSource linker=0) -> Animation
    _get_animation_impl(String name) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance__get_animation_impl__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);
  {
    try {
      result = (Ogre::Animation *)((Ogre::SkeletonInstance const *)arg1)->_getAnimationImpl((Ogre::String const &)*arg2,(Ogre::LinkedSkeletonAnimationSource const **)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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__get_animation_impl__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;
  }
  {
    try {
      result = (Ogre::Animation *)((Ogre::SkeletonInstance const *)arg1)->_getAnimationImpl((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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__get_animation_impl(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__get_animation_impl__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__get_animation_impl__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SkeletonInstance._get_animation_impl", 
    "    Ogre::Animation * SkeletonInstance._get_animation_impl(Ogre::String const &name, Ogre::LinkedSkeletonAnimationSource const **linker)\n"
    "    Ogre::Animation * SkeletonInstance._get_animation_impl(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance.create_animation

  call-seq:
    create_animation(String name, Real length) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_create_animation(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);
  {
    try {
      result = (Ogre::Animation *)(arg1)->createAnimation((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance.get_animation

  call-seq:
    get_animation(unsigned short index) -> Animation
    get_animation(String name, LinkedSkeletonAnimationSource linker=0) -> Animation
    get_animation(String name) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_get_animation__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);
  {
    try {
      result = (Ogre::Animation *)((Ogre::SkeletonInstance const *)arg1)->getAnimation((Ogre::String const &)*arg2,(Ogre::LinkedSkeletonAnimationSource const **)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_animation__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;
  }
  {
    try {
      result = (Ogre::Animation *)((Ogre::SkeletonInstance const *)arg1)->getAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_animation(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_get_animation__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_get_animation__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_get_animation__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SkeletonInstance.get_animation", 
    "    Ogre::Animation * SkeletonInstance.get_animation(unsigned short index)\n"
    "    Ogre::Animation * SkeletonInstance.get_animation(Ogre::String const &name, Ogre::LinkedSkeletonAnimationSource const **linker)\n"
    "    Ogre::Animation * SkeletonInstance.get_animation(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance.remove_animation

  call-seq:
    remove_animation(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_remove_animation(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;
  }
  {
    try {
      (arg1)->removeAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance.create_tag_point_on_bone

  call-seq:
    create_tag_point_on_bone(Bone bone, Quaternion offsetOrientation=IDENTITY, Vector3 offsetPosition=) -> TagPoint
    create_tag_point_on_bone(Bone bone, Quaternion offsetOrientation=IDENTITY) -> TagPoint
    create_tag_point_on_bone(Bone bone) -> TagPoint

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_create_tag_point_on_bone__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);
  {
    try {
      result = (Ogre::TagPoint *)(arg1)->createTagPointOnBone(arg2,(Ogre::Quaternion const &)*arg3,(Ogre::Vector3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TagPoint, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_create_tag_point_on_bone__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);
  {
    try {
      result = (Ogre::TagPoint *)(arg1)->createTagPointOnBone(arg2,(Ogre::Quaternion const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TagPoint, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_create_tag_point_on_bone__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);
  {
    try {
      result = (Ogre::TagPoint *)(arg1)->createTagPointOnBone(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TagPoint, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SkeletonInstance_create_tag_point_on_bone(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_create_tag_point_on_bone__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_create_tag_point_on_bone__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_create_tag_point_on_bone__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SkeletonInstance.create_tag_point_on_bone", 
    "    Ogre::TagPoint * SkeletonInstance.create_tag_point_on_bone(Ogre::Bone *bone, Ogre::Quaternion const &offsetOrientation, Ogre::Vector3 const &offsetPosition)\n"
    "    Ogre::TagPoint * SkeletonInstance.create_tag_point_on_bone(Ogre::Bone *bone, Ogre::Quaternion const &offsetOrientation)\n"
    "    Ogre::TagPoint * SkeletonInstance.create_tag_point_on_bone(Ogre::Bone *bone)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance.free_tag_point

  call-seq:
    free_tag_point(TagPoint tagPoint)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_free_tag_point(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);
  {
    try {
      (arg1)->freeTagPoint(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance.add_linked_skeleton_animation_source

  call-seq:
    add_linked_skeleton_animation_source(String skelName, Real scale=1.0)
    add_linked_skeleton_animation_source(String skelName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_add_linked_skeleton_animation_source__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);
  {
    try {
      (arg1)->addLinkedSkeletonAnimationSource((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_add_linked_skeleton_animation_source__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;
  }
  {
    try {
      (arg1)->addLinkedSkeletonAnimationSource((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SkeletonInstance_add_linked_skeleton_animation_source(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_add_linked_skeleton_animation_source__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_add_linked_skeleton_animation_source__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SkeletonInstance.add_linked_skeleton_animation_source", 
    "    void SkeletonInstance.add_linked_skeleton_animation_source(Ogre::String const &skelName, Ogre::Real scale)\n"
    "    void SkeletonInstance.add_linked_skeleton_animation_source(Ogre::String const &skelName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance.remove_all_linked_skeleton_animation_sources

  call-seq:
    remove_all_linked_skeleton_animation_sources

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_remove_all_linked_skeleton_animation_sources(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);
  {
    try {
      (arg1)->removeAllLinkedSkeletonAnimationSources();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance.get_linked_skeleton_animation_source_iterator

  call-seq:
    get_linked_skeleton_animation_source_iterator -> LinkedSkeletonAnimSourceIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_get_linked_skeleton_animation_source_iterator(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);
  {
    try {
      result = ((Ogre::SkeletonInstance const *)arg1)->getLinkedSkeletonAnimationSourceIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::SkeletonInstance._init_animation_state

  call-seq:
    _init_animation_state(AnimationStateSet animSet)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance__init_animation_state(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);
  {
    try {
      (arg1)->_initAnimationState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance._refresh_animation_state

  call-seq:
    _refresh_animation_state(AnimationStateSet animSet)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance__refresh_animation_state(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);
  {
    try {
      (arg1)->_refreshAnimationState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::SkeletonInstance const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance.get_handle

  call-seq:
    get_handle -> ResourceHandle

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_get_handle(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);
  {
    try {
      result = (Ogre::ResourceHandle)((Ogre::SkeletonInstance const *)arg1)->getHandle();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonInstance.get_group

  call-seq:
    get_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonInstance_get_group(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);
  {
    try {
      result = (Ogre::String *) &(arg1)->getGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::InstancedGeometry

  Proxy of C++ Ogre::InstancedGeometry class


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


/*
  Document-method: Ogre::InstancedGeometry.new

  call-seq:
    InstancedGeometry.new(SceneManager owner, String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::InstancedGeometry *)new Ogre::InstancedGeometry(arg1,(Ogre::String const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::InstancedGeometry.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::InstancedGeometry const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.add_entity

  call-seq:
    add_entity(Entity ent, Vector3 position, Quaternion orientation=IDENTITY, 
    Vector3 scale=UNIT_SCALE)
    add_entity(Entity ent, Vector3 position, Quaternion orientation=IDENTITY)
    add_entity(Entity ent, Vector3 position)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_add_entity__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);
  {
    try {
      (arg1)->addEntity(arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4,(Ogre::Vector3 const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_add_entity__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);
  {
    try {
      (arg1)->addEntity(arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_add_entity__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);
  {
    try {
      (arg1)->addEntity(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedGeometry_add_entity(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_add_entity__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_add_entity__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_add_entity__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "InstancedGeometry.add_entity", 
    "    void InstancedGeometry.add_entity(Ogre::Entity *ent, Ogre::Vector3 const &position, Ogre::Quaternion const &orientation, Ogre::Vector3 const &scale)\n"
    "    void InstancedGeometry.add_entity(Ogre::Entity *ent, Ogre::Vector3 const &position, Ogre::Quaternion const &orientation)\n"
    "    void InstancedGeometry.add_entity(Ogre::Entity *ent, Ogre::Vector3 const &position)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.add_scene_node

  call-seq:
    add_scene_node(SceneNode node)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_add_scene_node(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);
  {
    try {
      (arg1)->addSceneNode((Ogre::SceneNode const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.build

  call-seq:
    build

An instance method.

*/
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);
  {
    try {
      (arg1)->build();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.add_batch_instance

  call-seq:
    add_batch_instance

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_add_batch_instance(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);
  {
    try {
      (arg1)->addBatchInstance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.destroy

  call-seq:
    destroy

An instance method.

*/
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);
  {
    try {
      (arg1)->destroy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.reset

  call-seq:
    reset

An instance method.

*/
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);
  {
    try {
      (arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.set_rendering_distance

  call-seq:
    set_rendering_distance(Real dist)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_set_rendering_distance(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);
  {
    try {
      (arg1)->setRenderingDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_rendering_distance

  call-seq:
    get_rendering_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_rendering_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::InstancedGeometry const *)arg1)->getRenderingDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_squared_rendering_distance

  call-seq:
    get_squared_rendering_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_squared_rendering_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::InstancedGeometry const *)arg1)->getSquaredRenderingDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.set_visible

  call-seq:
    set_visible(bool visible)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_set_visible(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);
  {
    try {
      (arg1)->setVisible(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.is_visible

  call-seq:
    is_visible -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_is_visible(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);
  {
    try {
      result = (bool)((Ogre::InstancedGeometry const *)arg1)->isVisible();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.set_cast_shadows

  call-seq:
    set_cast_shadows(bool castShadows)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_set_cast_shadows(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);
  {
    try {
      (arg1)->setCastShadows(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_cast_shadows

  call-seq:
    get_cast_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_cast_shadows(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);
  {
    try {
      result = (bool)(arg1)->getCastShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.set_batch_instance_dimensions

  call-seq:
    set_batch_instance_dimensions(Vector3 size)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_set_batch_instance_dimensions(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);
  {
    try {
      (arg1)->setBatchInstanceDimensions((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_batch_instance_dimensions

  call-seq:
    get_batch_instance_dimensions -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_batch_instance_dimensions(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::InstancedGeometry const *)arg1)->getBatchInstanceDimensions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.set_origin

  call-seq:
    set_origin(Vector3 origin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_set_origin(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);
  {
    try {
      (arg1)->setOrigin((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_origin

  call-seq:
    get_origin -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_origin(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::InstancedGeometry const *)arg1)->getOrigin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.set_render_queue_group

  call-seq:
    set_render_queue_group(uint8 queueID)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_set_render_queue_group(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);
  {
    try {
      (arg1)->setRenderQueueGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_render_queue_group

  call-seq:
    get_render_queue_group -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_render_queue_group(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::InstancedGeometry const *)arg1)->getRenderQueueGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_batch_instance_iterator

  call-seq:
    get_batch_instance_iterator -> BatchInstanceIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_batch_instance_iterator(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);
  {
    try {
      result = (arg1)->getBatchInstanceIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::InstancedGeometry::BatchInstanceIterator(static_cast< const Ogre::InstancedGeometry::BatchInstanceIterator& >(result))), SWIGTYPE_p_Ogre__InstancedGeometry__BatchInstanceIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_render_operation_vector

  call-seq:
    get_render_operation_vector -> RenderOperationVector

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_render_operation_vector(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);
  {
    try {
      result = (Ogre::InstancedGeometry::RenderOperationVector *) &(arg1)->getRenderOperationVector();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__RenderOperation_p_Ogre__STLAllocatorT_Ogre__RenderOperation_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedGeometry_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstancedGeometry.visit_renderables", 
    "    void InstancedGeometry.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void InstancedGeometry.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.dump

  call-seq:
    dump(String filename)

An instance method.

*/
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;
  }
  {
    try {
      ((Ogre::InstancedGeometry const *)arg1)->dump((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_base_skeleton_instance

  call-seq:
    get_base_skeleton_instance -> SkeletonInstance

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_base_skeleton_instance(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);
  {
    try {
      result = (Ogre::SkeletonInstance *)(arg1)->getBaseSkeletonInstance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_base_skeleton

  call-seq:
    get_base_skeleton -> SkeletonPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_base_skeleton(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);
  {
    try {
      result = (arg1)->getBaseSkeleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::SkeletonPtr(static_cast< const Ogre::SkeletonPtr& >(result))), SWIGTYPE_p_Ogre__SkeletonPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_base_animation_state

  call-seq:
    get_base_animation_state -> AnimationStateSet

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_base_animation_state(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);
  {
    try {
      result = (Ogre::AnimationStateSet *)(arg1)->getBaseAnimationState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_object_count

  call-seq:
    get_object_count -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_object_count(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);
  {
    try {
      result = (unsigned int)(arg1)->getObjectCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.set_provide_world_inverses

  call-seq:
    set_provide_world_inverses(bool flag)

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_set_provide_world_inverses(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);
  {
    try {
      (arg1)->setProvideWorldInverses(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::InstancedGeometry.get_provide_world_inverses

  call-seq:
    get_provide_world_inverses -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_InstancedGeometry_get_provide_world_inverses(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);
  {
    try {
      result = (bool)((Ogre::InstancedGeometry const *)arg1)->getProvideWorldInverses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::MovableObjectLodChangedEvent

  Proxy of C++ Ogre::MovableObjectLodChangedEvent class


*/
swig_class SwigClassMovableObjectLodChangedEvent;


/*
  Document-method: Ogre::MovableObjectLodChangedEvent.movableObject

  call-seq:
    movableObject -> MovableObject

Get value of attribute.

*/

/*
  Document-method: Ogre::MovableObjectLodChangedEvent.movableObject=

  call-seq:
    movableObject=(x) -> MovableObject

Set new value for attribute.

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



/*
  Document-method: Ogre::MovableObjectLodChangedEvent.camera

  call-seq:
    camera -> Camera

Get value of attribute.

*/

/*
  Document-method: Ogre::MovableObjectLodChangedEvent.camera=

  call-seq:
    camera=(x) -> Camera

Set new value for attribute.

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


/*
  Document-method: Ogre::MovableObjectLodChangedEvent.new

  call-seq:
    MovableObjectLodChangedEvent.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::MovableObjectLodChangedEvent *)new Ogre::MovableObjectLodChangedEvent();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MovableObjectLodChangedEvent(Ogre::MovableObjectLodChangedEvent *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::EntityMeshLodChangedEvent

  Proxy of C++ Ogre::EntityMeshLodChangedEvent class


*/
swig_class SwigClassEntityMeshLodChangedEvent;


/*
  Document-method: Ogre::EntityMeshLodChangedEvent.entity

  call-seq:
    entity -> Entity

Get value of attribute.

*/

/*
  Document-method: Ogre::EntityMeshLodChangedEvent.entity=

  call-seq:
    entity=(x) -> Entity

Set new value for attribute.

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



/*
  Document-method: Ogre::EntityMeshLodChangedEvent.camera

  call-seq:
    camera -> Camera

Get value of attribute.

*/

/*
  Document-method: Ogre::EntityMeshLodChangedEvent.camera=

  call-seq:
    camera=(x) -> Camera

Set new value for attribute.

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



/*
  Document-method: Ogre::EntityMeshLodChangedEvent.lodValue

  call-seq:
    lodValue -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::EntityMeshLodChangedEvent.lodValue=

  call-seq:
    lodValue=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::EntityMeshLodChangedEvent.previousLodIndex

  call-seq:
    previousLodIndex -> ushort

Get value of attribute.

*/

/*
  Document-method: Ogre::EntityMeshLodChangedEvent.previousLodIndex=

  call-seq:
    previousLodIndex=(x) -> ushort

Set new value for attribute.

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



/*
  Document-method: Ogre::EntityMeshLodChangedEvent.newLodIndex

  call-seq:
    newLodIndex -> ushort

Get value of attribute.

*/

/*
  Document-method: Ogre::EntityMeshLodChangedEvent.newLodIndex=

  call-seq:
    newLodIndex=(x) -> ushort

Set new value for attribute.

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


/*
  Document-method: Ogre::EntityMeshLodChangedEvent.new

  call-seq:
    EntityMeshLodChangedEvent.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EntityMeshLodChangedEvent *)new Ogre::EntityMeshLodChangedEvent();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EntityMeshLodChangedEvent(Ogre::EntityMeshLodChangedEvent *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::EntityMaterialLodChangedEvent

  Proxy of C++ Ogre::EntityMaterialLodChangedEvent class


*/
swig_class SwigClassEntityMaterialLodChangedEvent;


/*
  Document-method: Ogre::EntityMaterialLodChangedEvent.subEntity

  call-seq:
    subEntity -> SubEntity

Get value of attribute.

*/

/*
  Document-method: Ogre::EntityMaterialLodChangedEvent.subEntity=

  call-seq:
    subEntity=(x) -> SubEntity

Set new value for attribute.

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



/*
  Document-method: Ogre::EntityMaterialLodChangedEvent.camera

  call-seq:
    camera -> Camera

Get value of attribute.

*/

/*
  Document-method: Ogre::EntityMaterialLodChangedEvent.camera=

  call-seq:
    camera=(x) -> Camera

Set new value for attribute.

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



/*
  Document-method: Ogre::EntityMaterialLodChangedEvent.lodValue

  call-seq:
    lodValue -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::EntityMaterialLodChangedEvent.lodValue=

  call-seq:
    lodValue=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::EntityMaterialLodChangedEvent.previousLodIndex

  call-seq:
    previousLodIndex -> ushort

Get value of attribute.

*/

/*
  Document-method: Ogre::EntityMaterialLodChangedEvent.previousLodIndex=

  call-seq:
    previousLodIndex=(x) -> ushort

Set new value for attribute.

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



/*
  Document-method: Ogre::EntityMaterialLodChangedEvent.newLodIndex

  call-seq:
    newLodIndex -> ushort

Get value of attribute.

*/

/*
  Document-method: Ogre::EntityMaterialLodChangedEvent.newLodIndex=

  call-seq:
    newLodIndex=(x) -> ushort

Set new value for attribute.

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


/*
  Document-method: Ogre::EntityMaterialLodChangedEvent.new

  call-seq:
    EntityMaterialLodChangedEvent.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EntityMaterialLodChangedEvent *)new Ogre::EntityMaterialLodChangedEvent();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EntityMaterialLodChangedEvent(Ogre::EntityMaterialLodChangedEvent *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::LodListener

  Proxy of C++ Ogre::LodListener class


*/
swig_class SwigClassLodListener;

SWIGINTERN void
free_Ogre_LodListener(Ogre::LodListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::LodListener.prequeue_movable_object_lod_changed

  call-seq:
    prequeue_movable_object_lod_changed(MovableObjectLodChangedEvent evt) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodListener_prequeue_movable_object_lod_changed(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 {
    {
      try {
        if (upcall) {
          result = (bool)(arg1)->Ogre::LodListener::prequeueMovableObjectLodChanged((Ogre::MovableObjectLodChangedEvent const &)*arg2);
        } else {
          result = (bool)(arg1)->prequeueMovableObjectLodChanged((Ogre::MovableObjectLodChangedEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodListener.postqueue_movable_object_lod_changed

  call-seq:
    postqueue_movable_object_lod_changed(MovableObjectLodChangedEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodListener_postqueue_movable_object_lod_changed(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::LodListener::postqueueMovableObjectLodChanged((Ogre::MovableObjectLodChangedEvent const &)*arg2);
        } else {
          (arg1)->postqueueMovableObjectLodChanged((Ogre::MovableObjectLodChangedEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodListener.prequeue_entity_mesh_lod_changed

  call-seq:
    prequeue_entity_mesh_lod_changed(EntityMeshLodChangedEvent evt) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodListener_prequeue_entity_mesh_lod_changed(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 {
    {
      try {
        if (upcall) {
          result = (bool)(arg1)->Ogre::LodListener::prequeueEntityMeshLodChanged(*arg2);
        } else {
          result = (bool)(arg1)->prequeueEntityMeshLodChanged(*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodListener.postqueue_entity_mesh_lod_changed

  call-seq:
    postqueue_entity_mesh_lod_changed(EntityMeshLodChangedEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodListener_postqueue_entity_mesh_lod_changed(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::LodListener::postqueueEntityMeshLodChanged((Ogre::EntityMeshLodChangedEvent const &)*arg2);
        } else {
          (arg1)->postqueueEntityMeshLodChanged((Ogre::EntityMeshLodChangedEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodListener.prequeue_entity_material_lod_changed

  call-seq:
    prequeue_entity_material_lod_changed(EntityMaterialLodChangedEvent evt) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodListener_prequeue_entity_material_lod_changed(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 {
    {
      try {
        if (upcall) {
          result = (bool)(arg1)->Ogre::LodListener::prequeueEntityMaterialLodChanged(*arg2);
        } else {
          result = (bool)(arg1)->prequeueEntityMaterialLodChanged(*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodListener.postqueue_entity_material_lod_changed

  call-seq:
    postqueue_entity_material_lod_changed(EntityMaterialLodChangedEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodListener_postqueue_entity_material_lod_changed(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 {
    {
      try {
        if (upcall) {
          (arg1)->Ogre::LodListener::postqueueEntityMaterialLodChanged((Ogre::EntityMaterialLodChangedEvent const &)*arg2);
        } else {
          (arg1)->postqueueEntityMaterialLodChanged((Ogre::EntityMaterialLodChangedEvent const &)*arg2);
        }
      } catch(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } 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;
  }
  


/*
  Document-method: Ogre::LodListener.new

  call-seq:
    LodListener.new

Class constructor.

*/
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;
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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;
}



/*
  Document-class: Ogre::LodStrategyManager

  Proxy of C++ Ogre::LodStrategyManager class


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


/*
  Document-method: Ogre::LodStrategyManager.new

  call-seq:
    LodStrategyManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::LodStrategyManager *)new Ogre::LodStrategyManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_LodStrategyManager(Ogre::LodStrategyManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::LodStrategyManager.add_strategy

  call-seq:
    add_strategy(LodStrategy strategy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategyManager_add_strategy(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);
  {
    try {
      (arg1)->addStrategy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategyManager.remove_strategy

  call-seq:
    remove_strategy(String name) -> LodStrategy

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategyManager_remove_strategy(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;
  }
  {
    try {
      result = (Ogre::LodStrategy *)(arg1)->removeStrategy((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategyManager.remove_all_strategies

  call-seq:
    remove_all_strategies

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategyManager_remove_all_strategies(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);
  {
    try {
      (arg1)->removeAllStrategies();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategyManager.get_strategy

  call-seq:
    get_strategy(String name) -> LodStrategy

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategyManager_get_strategy(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;
  }
  {
    try {
      result = (Ogre::LodStrategy *)(arg1)->getStrategy((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategyManager.set_default_strategy

  call-seq:
    set_default_strategy(LodStrategy strategy)
    set_default_strategy(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategyManager_set_default_strategy__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);
  {
    try {
      (arg1)->setDefaultStrategy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategyManager_set_default_strategy__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;
  }
  {
    try {
      (arg1)->setDefaultStrategy((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_LodStrategyManager_set_default_strategy(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_set_default_strategy__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_set_default_strategy__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "LodStrategyManager.set_default_strategy", 
    "    void LodStrategyManager.set_default_strategy(Ogre::LodStrategy *strategy)\n"
    "    void LodStrategyManager.set_default_strategy(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategyManager.get_default_strategy

  call-seq:
    get_default_strategy -> LodStrategy

An instance method.

*/
SWIGINTERN VALUE
_wrap_LodStrategyManager_get_default_strategy(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);
  {
    try {
      result = (Ogre::LodStrategy *)(arg1)->getDefaultStrategy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategyManager.get_singleton

  call-seq:
    get_singleton -> LodStrategyManager

A class method.

*/
SWIGINTERN VALUE
_wrap_LodStrategyManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::LodStrategyManager *) &Ogre::LodStrategyManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategyManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LodStrategyManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> LodStrategyManager

A class method.

*/
SWIGINTERN VALUE
_wrap_LodStrategyManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::LodStrategyManager *)Ogre::LodStrategyManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategyManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ManualObject < Ogre::Ogre::MovableObject

  Proxy of C++ Ogre::ManualObject class


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


/*
  Document-method: Ogre::ManualObject.new

  call-seq:
    ManualObject.new(String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ManualObject *)new Ogre::ManualObject((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.estimate_vertex_count

  call-seq:
    estimate_vertex_count(size_t vcount)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_estimate_vertex_count(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);
  {
    try {
      (arg1)->estimateVertexCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.estimate_index_count

  call-seq:
    estimate_index_count(size_t icount)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_estimate_index_count(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);
  {
    try {
      (arg1)->estimateIndexCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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;
  }
  {
    try {
      (arg1)->begin((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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);
  {
    try {
      (arg1)->begin((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN 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;
  }
  {
    try {
      (arg1)->begin((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


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



/*
  Document-method: Ogre::ManualObject.set_dynamic

  call-seq:
    set_dynamic(bool dyn)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_set_dynamic(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);
  {
    try {
      (arg1)->setDynamic(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_dynamic

  call-seq:
    get_dynamic -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_dynamic(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);
  {
    try {
      result = (bool)((Ogre::ManualObject const *)arg1)->getDynamic();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.begin_update

  call-seq:
    begin_update(size_t sectionIndex)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_begin_update(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);
  {
    try {
      (arg1)->beginUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.position

  call-seq:
    position(Vector3 pos)
    position(Real x, Real y, Real z)

An instance method.

*/
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);
  {
    try {
      (arg1)->position((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->position(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::ManualObject.normal

  call-seq:
    normal(Vector3 norm)
    normal(Real x, Real y, Real z)

An instance method.

*/
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);
  {
    try {
      (arg1)->normal((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->normal(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::ManualObject.tangent

  call-seq:
    tangent(Vector3 tan)
    tangent(Real x, Real y, Real z)

An instance method.

*/
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);
  {
    try {
      (arg1)->tangent((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->tangent(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::ManualObject.texture_coord

  call-seq:
    texture_coord(Real u)
    texture_coord(Real u, Real v)
    texture_coord(Real u, Real v, Real w)
    texture_coord(Real x, Real y, Real z, Real w)
    texture_coord(Vector2 uv)
    texture_coord(Vector3 uvw)
    texture_coord(Vector4 xyzw)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_texture_coord__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);
  {
    try {
      (arg1)->textureCoord(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_texture_coord__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);
  {
    try {
      (arg1)->textureCoord(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_texture_coord__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);
  {
    try {
      (arg1)->textureCoord(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_texture_coord__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);
  {
    try {
      (arg1)->textureCoord(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_texture_coord__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);
  {
    try {
      (arg1)->textureCoord((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_texture_coord__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);
  {
    try {
      (arg1)->textureCoord((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_texture_coord__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);
  {
    try {
      (arg1)->textureCoord((Ogre::Vector4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_texture_coord(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_texture_coord__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_texture_coord__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_texture_coord__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_texture_coord__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_texture_coord__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_texture_coord__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_texture_coord__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ManualObject.texture_coord", 
    "    void ManualObject.texture_coord(Ogre::Real u)\n"
    "    void ManualObject.texture_coord(Ogre::Real u, Ogre::Real v)\n"
    "    void ManualObject.texture_coord(Ogre::Real u, Ogre::Real v, Ogre::Real w)\n"
    "    void ManualObject.texture_coord(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Real w)\n"
    "    void ManualObject.texture_coord(Ogre::Vector2 const &uv)\n"
    "    void ManualObject.texture_coord(Ogre::Vector3 const &uvw)\n"
    "    void ManualObject.texture_coord(Ogre::Vector4 const &xyzw)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.colour

  call-seq:
    colour(ColourValue col)
    colour(Real r, Real g, Real b, Real a=1.0)
    colour(Real r, Real g, Real b)

An instance method.

*/
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);
  {
    try {
      (arg1)->colour((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->colour(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->colour(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::ManualObject.index

  call-seq:
    index(uint32 idx)

An instance method.

*/
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);
  {
    try {
      (arg1)->index(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.triangle

  call-seq:
    triangle(uint32 i1, uint32 i2, uint32 i3)

An instance method.

*/
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);
  {
    try {
      (arg1)->triangle(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.quad

  call-seq:
    quad(uint32 i1, uint32 i2, uint32 i3, uint32 i4)

An instance method.

*/
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);
  {
    try {
      (arg1)->quad(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_current_vertex_count

  call-seq:
    get_current_vertex_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_current_vertex_count(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);
  {
    try {
      result = ((Ogre::ManualObject const *)arg1)->getCurrentVertexCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_current_index_count

  call-seq:
    get_current_index_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_current_index_count(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);
  {
    try {
      result = ((Ogre::ManualObject const *)arg1)->getCurrentIndexCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (Ogre::ManualObject::ManualObjectSection *)(arg1)->end();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ManualObject__ManualObjectSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.set_material_name

  call-seq:
    set_material_name(size_t subindex, String name, String group=DEFAULT_RESOURCE_GROUP_NAME)
    set_material_name(size_t subindex, String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName(arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_set_material_name(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_set_material_name__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_set_material_name__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ManualObject.set_material_name", 
    "    void ManualObject.set_material_name(size_t subindex, Ogre::String const &name, Ogre::String const &group)\n"
    "    void ManualObject.set_material_name(size_t subindex, Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.convert_to_mesh

  call-seq:
    convert_to_mesh(String meshName, String groupName=DEFAULT_RESOURCE_GROUP_NAME) -> MeshPtr
    convert_to_mesh(String meshName) -> MeshPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_convert_to_mesh__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;
  }
  {
    try {
      result = (arg1)->convertToMesh((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_convert_to_mesh__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;
  }
  {
    try {
      result = (arg1)->convertToMesh((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_convert_to_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_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_convert_to_mesh__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_convert_to_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ManualObject.convert_to_mesh", 
    "    Ogre::MeshPtr ManualObject.convert_to_mesh(Ogre::String const &meshName, Ogre::String const &groupName)\n"
    "    Ogre::MeshPtr ManualObject.convert_to_mesh(Ogre::String const &meshName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.set_use_identity_projection

  call-seq:
    set_use_identity_projection(bool useIdentityProjection)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_set_use_identity_projection(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);
  {
    try {
      (arg1)->setUseIdentityProjection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_use_identity_projection

  call-seq:
    get_use_identity_projection -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_use_identity_projection(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);
  {
    try {
      result = (bool)((Ogre::ManualObject const *)arg1)->getUseIdentityProjection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.set_use_identity_view

  call-seq:
    set_use_identity_view(bool useIdentityView)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_set_use_identity_view(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);
  {
    try {
      (arg1)->setUseIdentityView(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_use_identity_view

  call-seq:
    get_use_identity_view -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_use_identity_view(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);
  {
    try {
      result = (bool)((Ogre::ManualObject const *)arg1)->getUseIdentityView();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.set_bounding_box

  call-seq:
    set_bounding_box(AxisAlignedBox box)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_set_bounding_box(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);
  {
    try {
      (arg1)->setBoundingBox((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_section

  call-seq:
    get_section(unsigned int index) -> ManualObjectSection

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_section(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);
  {
    try {
      result = (Ogre::ManualObject::ManualObjectSection *)((Ogre::ManualObject const *)arg1)->getSection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ManualObject__ManualObjectSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_num_sections

  call-seq:
    get_num_sections -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_num_sections(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);
  {
    try {
      result = (unsigned int)((Ogre::ManualObject const *)arg1)->getNumSections();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.set_keep_declaration_order

  call-seq:
    set_keep_declaration_order(bool keepOrder)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_set_keep_declaration_order(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);
  {
    try {
      (arg1)->setKeepDeclarationOrder(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_keep_declaration_order

  call-seq:
    get_keep_declaration_order -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_keep_declaration_order(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);
  {
    try {
      result = (bool)((Ogre::ManualObject const *)arg1)->getKeepDeclarationOrder();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ManualObject const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::ManualObject const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ManualObject const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_edge_list

  call-seq:
    get_edge_list -> EdgeData

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_edge_list(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);
  {
    try {
      result = (Ogre::EdgeData *)(arg1)->getEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.has_edge_list

  call-seq:
    has_edge_list -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_has_edge_list(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);
  {
    try {
      result = (bool)(arg1)->hasEdgeList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.get_shadow_volume_renderable_iterator

  call-seq:
    get_shadow_volume_renderable_iterator(ShadowTechnique shadowTechnique, Light light, HardwareIndexBufferSharedPtr indexBuffer, 
    bool extrudeVertices, 
    Real extrusionDist, unsigned long flags=0) -> ShadowRenderableListIterator
    get_shadow_volume_renderable_iterator(ShadowTechnique shadowTechnique, Light light, HardwareIndexBufferSharedPtr indexBuffer, 
    bool extrudeVertices, 
    Real extrusionDist) -> ShadowRenderableListIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_get_shadow_volume_renderable_iterator__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);
  {
    try {
      result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_shadow_volume_renderable_iterator__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);
  {
    try {
      result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_shadow_volume_renderable_iterator(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_get_shadow_volume_renderable_iterator__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_get_shadow_volume_renderable_iterator__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "ManualObject.get_shadow_volume_renderable_iterator", 
    "    Ogre::ShadowCaster::ShadowRenderableListIterator ManualObject.get_shadow_volume_renderable_iterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDist, unsigned long flags)\n"
    "    Ogre::ShadowCaster::ShadowRenderableListIterator ManualObject.get_shadow_volume_renderable_iterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDist)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObject_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ManualObject.visit_renderables", 
    "    void ManualObject.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void ManualObject.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::ManualObjectFactory < Ogre::Ogre::MovableObjectFactory

  Proxy of C++ Ogre::ManualObjectFactory class


*/
swig_class SwigClassManualObjectFactory;

SWIGINTERN void
free_Ogre_ManualObjectFactory(Ogre::ManualObjectFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ManualObjectFactory.FACTORY_TYPE_NAME

  call-seq:
    FACTORY_TYPE_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ManualObjectFactory.FACTORY_TYPE_NAME=

  call-seq:
    FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::ManualObjectFactory.ManualObjectFactory_FACTORY_TYPE_NAME

  call-seq:
    ManualObjectFactory_FACTORY_TYPE_NAME -> String

Get value of attribute.

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



/*
  Document-method: Ogre::ManualObjectFactory.ManualObjectFactory_FACTORY_TYPE_NAME=

  call-seq:
    ManualObjectFactory_FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ManualObjectFactory.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObjectFactory_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ManualObjectFactory const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObjectFactory.destroy_instance

  call-seq:
    destroy_instance(MovableObject obj)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ManualObjectFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::NedPoolingImpl

  Proxy of C++ Ogre::NedPoolingImpl class


*/
swig_class SwigClassNedPoolingImpl;


/*
  Document-method: Ogre::NedPoolingImpl.alloc_bytes

  call-seq:
    alloc_bytes(size_t count, char file, int line, char func) -> void

A class method.

*/
SWIGINTERN VALUE
_wrap_NedPoolingImpl_alloc_bytes(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);
  {
    try {
      result = (void *)Ogre::NedPoolingImpl::allocBytes(arg1,(char const *)arg2,arg3,(char const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
}



/*
  Document-method: Ogre::NedPoolingImpl.dealloc_bytes

  call-seq:
    dealloc_bytes(void ptr)

A class method.

*/
SWIGINTERN VALUE
_wrap_NedPoolingImpl_dealloc_bytes(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] )); 
  }
  {
    try {
      Ogre::NedPoolingImpl::deallocBytes(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NedPoolingImpl.alloc_bytes_aligned

  call-seq:
    alloc_bytes_aligned(size_t align, size_t count, char file, int line, char func) -> void

A class method.

*/
SWIGINTERN VALUE
_wrap_NedPoolingImpl_alloc_bytes_aligned(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);
  {
    try {
      result = (void *)Ogre::NedPoolingImpl::allocBytesAligned(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
}



/*
  Document-method: Ogre::NedPoolingImpl.dealloc_bytes_aligned

  call-seq:
    dealloc_bytes_aligned(size_t align, void ptr)

A class method.

*/
SWIGINTERN VALUE
_wrap_NedPoolingImpl_dealloc_bytes_aligned(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] )); 
  }
  {
    try {
      Ogre::NedPoolingImpl::deallocBytesAligned(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::NedPoolingImpl.new

  call-seq:
    NedPoolingImpl.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::NedPoolingImpl *)new Ogre::NedPoolingImpl();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_NedPoolingImpl(Ogre::NedPoolingImpl *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::NedPoolingPolicy

  Proxy of C++ Ogre::NedPoolingPolicy class


*/
swig_class SwigClassNedPoolingPolicy;


/*
  Document-method: Ogre::NedPoolingPolicy.allocate_bytes

  call-seq:
    allocate_bytes(size_t count, char file=0, int line=0, char func=0) -> void
    allocate_bytes(size_t count, char file=0, int line=0)
    allocate_bytes(size_t count, char file=0)
    allocate_bytes(size_t count)

A class method.

*/
SWIGINTERN VALUE
_wrap_NedPoolingPolicy_allocate_bytes__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);
  {
    try {
      result = (void *)Ogre::NedPoolingPolicy::allocateBytes(arg1,(char const *)arg2,arg3,(char const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_allocate_bytes__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);
  {
    try {
      result = (void *)Ogre::NedPoolingPolicy::allocateBytes(arg1,(char const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NedPoolingPolicy_allocate_bytes__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);
  {
    try {
      result = (void *)Ogre::NedPoolingPolicy::allocateBytes(arg1,(char const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NedPoolingPolicy_allocate_bytes__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);
  {
    try {
      result = (void *)Ogre::NedPoolingPolicy::allocateBytes(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_NedPoolingPolicy_allocate_bytes(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_allocate_bytes__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_allocate_bytes__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_allocate_bytes__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_allocate_bytes__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "NedPoolingPolicy.allocate_bytes", 
    "    void * NedPoolingPolicy.allocate_bytes(size_t count, char const *file, int line, char const *func)\n"
    "    void * NedPoolingPolicy.allocate_bytes(size_t count, char const *file, int line)\n"
    "    void * NedPoolingPolicy.allocate_bytes(size_t count, char const *file)\n"
    "    void * NedPoolingPolicy.allocate_bytes(size_t count)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::NedPoolingPolicy.deallocate_bytes

  call-seq:
    deallocate_bytes(void ptr)

A class method.

*/
SWIGINTERN VALUE
_wrap_NedPoolingPolicy_deallocate_bytes(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] )); 
  }
  {
    try {
      Ogre::NedPoolingPolicy::deallocateBytes(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::NedPoolingPolicy.get_max_allocation_size

  call-seq:
    get_max_allocation_size -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_NedPoolingPolicy_get_max_allocation_size(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;
  }
  {
    try {
      result = Ogre::NedPoolingPolicy::getMaxAllocationSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_NedPoolingPolicy(Ogre::NedPoolingPolicy *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::PatchSurface

  Proxy of C++ Ogre::PatchSurface class


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


/*
  Document-method: Ogre::PatchSurface.new

  call-seq:
    PatchSurface.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PatchSurface *)new Ogre::PatchSurface();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PatchSurface(Ogre::PatchSurface *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PatchSurfaceType.PST_BEZIER

  call-seq:
    PST_BEZIER -> int

A class method.

*/

/*
  Document-method: Ogre.AUTO_LEVEL

  call-seq:
    AUTO_LEVEL -> int

A class method.

*/

/*
  Document-method: Ogre::VisibleSide.VS_FRONT

  call-seq:
    VS_FRONT -> int

A class method.

*/

/*
  Document-method: Ogre::VisibleSide.VS_BACK

  call-seq:
    VS_BACK -> int

A class method.

*/

/*
  Document-method: Ogre::VisibleSide.VS_BOTH

  call-seq:
    VS_BOTH -> int

A class method.

*/

/*
  Document-method: Ogre::PatchSurface.define_surface

  call-seq:
    define_surface(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height, PatchSurfaceType pType=PST_BEZIER, 
    size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL, 
    VisibleSide visibleSide=VS_FRONT)
    define_surface(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height, PatchSurfaceType pType=PST_BEZIER, 
    size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL)
    define_surface(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height, PatchSurfaceType pType=PST_BEZIER, 
    size_t uMaxSubdivisionLevel=AUTO_LEVEL)
    define_surface(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height, PatchSurfaceType pType=PST_BEZIER)
    define_surface(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchSurface_define_surface__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);
  {
    try {
      (arg1)->defineSurface(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_define_surface__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);
  {
    try {
      (arg1)->defineSurface(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_define_surface__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);
  {
    try {
      (arg1)->defineSurface(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_define_surface__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);
  {
    try {
      (arg1)->defineSurface(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_define_surface__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);
  {
    try {
      (arg1)->defineSurface(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PatchSurface_define_surface(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_define_surface__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_define_surface__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_define_surface__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_define_surface__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_define_surface__SWIG_0(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 10, "PatchSurface.define_surface", 
    "    void PatchSurface.define_surface(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.define_surface(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, Ogre::PatchSurface::PatchSurfaceType pType, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel)\n"
    "    void PatchSurface.define_surface(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, Ogre::PatchSurface::PatchSurfaceType pType, size_t uMaxSubdivisionLevel)\n"
    "    void PatchSurface.define_surface(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, Ogre::PatchSurface::PatchSurfaceType pType)\n"
    "    void PatchSurface.define_surface(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PatchSurface.get_required_vertex_count

  call-seq:
    get_required_vertex_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchSurface_get_required_vertex_count(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);
  {
    try {
      result = ((Ogre::PatchSurface const *)arg1)->getRequiredVertexCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PatchSurface.get_required_index_count

  call-seq:
    get_required_index_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchSurface_get_required_index_count(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);
  {
    try {
      result = ((Ogre::PatchSurface const *)arg1)->getRequiredIndexCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PatchSurface.get_current_index_count

  call-seq:
    get_current_index_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchSurface_get_current_index_count(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);
  {
    try {
      result = ((Ogre::PatchSurface const *)arg1)->getCurrentIndexCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PatchSurface.get_index_offset

  call-seq:
    get_index_offset -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchSurface_get_index_offset(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);
  {
    try {
      result = ((Ogre::PatchSurface const *)arg1)->getIndexOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PatchSurface.get_vertex_offset

  call-seq:
    get_vertex_offset -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchSurface_get_vertex_offset(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);
  {
    try {
      result = ((Ogre::PatchSurface const *)arg1)->getVertexOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PatchSurface.get_bounds

  call-seq:
    get_bounds -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchSurface_get_bounds(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::PatchSurface const *)arg1)->getBounds();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PatchSurface.get_bounding_sphere_radius

  call-seq:
    get_bounding_sphere_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchSurface_get_bounding_sphere_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::PatchSurface const *)arg1)->getBoundingSphereRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PatchSurface.build

  call-seq:
    build(HardwareVertexBufferSharedPtr destVertexBuffer, size_t vertexStart, 
    HardwareIndexBufferSharedPtr destIndexBuffer, 
    size_t indexStart)

An instance method.

*/
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);
  {
    try {
      (arg1)->build(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PatchSurface.set_subdivision_factor

  call-seq:
    set_subdivision_factor(Real factor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchSurface_set_subdivision_factor(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);
  {
    try {
      (arg1)->setSubdivisionFactor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PatchSurface.get_subdivision_factor

  call-seq:
    get_subdivision_factor -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchSurface_get_subdivision_factor(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);
  {
    try {
      result = (Ogre::Real)((Ogre::PatchSurface const *)arg1)->getSubdivisionFactor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PatchSurface.get_control_point_buffer

  call-seq:
    get_control_point_buffer -> void

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchSurface_get_control_point_buffer(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);
  {
    try {
      result = (void *)((Ogre::PatchSurface const *)arg1)->getControlPointBuffer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PatchSurface.notify_control_point_buffer_deallocated

  call-seq:
    notify_control_point_buffer_deallocated

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchSurface_notify_control_point_buffer_deallocated(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);
  {
    try {
      (arg1)->notifyControlPointBufferDeallocated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PatchMesh < Ogre::Ogre::Mesh

  Proxy of C++ Ogre::PatchMesh class


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


/*
  Document-method: Ogre::PatchMesh.new

  call-seq:
    PatchMesh.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PatchMesh *)new Ogre::PatchMesh(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::PatchMesh.update

  call-seq:
    update(void controlPointBuffer, size_t width, size_t height, 
    size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, 
    VisibleSide visibleSide)

An instance method.

*/
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);
  {
    try {
      (arg1)->update(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PatchMesh.define

  call-seq:
    define(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL, 
    VisibleSide visibleSide=VS_FRONT, 
    Usage vbUsage=HBU_STATIC_WRITE_ONLY, 
    Usage ibUsage=HBU_DYNAMIC_WRITE_ONLY, bool vbUseShadow=false, 
    bool ibUseShadow=false)
    define(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL, 
    VisibleSide visibleSide=VS_FRONT, 
    Usage vbUsage=HBU_STATIC_WRITE_ONLY, 
    Usage ibUsage=HBU_DYNAMIC_WRITE_ONLY, bool vbUseShadow=false)
    define(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL, 
    VisibleSide visibleSide=VS_FRONT, 
    Usage vbUsage=HBU_STATIC_WRITE_ONLY, 
    Usage ibUsage=HBU_DYNAMIC_WRITE_ONLY)
    define(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL, 
    VisibleSide visibleSide=VS_FRONT, 
    Usage vbUsage=HBU_STATIC_WRITE_ONLY)
    define(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL, 
    VisibleSide visibleSide=VS_FRONT)
    define(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL)
    define(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL)
    define(void controlPointBuffer, VertexDeclaration declaration, 
    size_t width, size_t height)

An instance method.

*/
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);
  {
    try {
      (arg1)->define(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->define(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->define(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->define(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->define(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->define(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->define(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->define(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::PatchMesh.set_subdivision

  call-seq:
    set_subdivision(Real factor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PatchMesh_set_subdivision(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);
  {
    try {
      (arg1)->setSubdivision(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PatchMesh(Ogre::PatchMesh *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::PatchMeshPtr

  Proxy of C++ Ogre::PatchMeshPtr class


*/
swig_class SwigClassPatchMeshPtr;


/*
  Document-method: Ogre::PatchMeshPtr.new

  call-seq:
    PatchMeshPtr.new
    PatchMeshPtr.new(PatchMesh rep)
    PatchMeshPtr.new(PatchMeshPtr r)
    PatchMeshPtr.new(ResourcePtr r)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PatchMeshPtr *)new Ogre::PatchMeshPtr();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::PatchMeshPtr *)new Ogre::PatchMeshPtr(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::PatchMeshPtr *)new Ogre::PatchMeshPtr((Ogre::PatchMeshPtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::PatchMeshPtr *)new Ogre::PatchMeshPtr((Ogre::ResourcePtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::MeshManager < Ogre::Ogre::ResourceManager, Ogre::Ogre::ManualResourceLoader

  Proxy of C++ Ogre::MeshManager class


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


/*
  Document-method: Ogre::MeshManager.new

  call-seq:
    MeshManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::MeshManager *)new Ogre::MeshManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MeshManager(Ogre::MeshManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::MeshManager._initialise

  call-seq:
    _initialise

An instance method.

*/
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);
  {
    try {
      (arg1)->_initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.create_or_retrieve

  call-seq:
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList params=0, 
    Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexBufferShadowed=true, 
    bool indexBufferShadowed=true) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList params=0, 
    Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexBufferShadowed=true) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList params=0, 
    Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList params=0, 
    Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0, 
    NameValuePairList params=0) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false, ManualResourceLoader loader=0) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group, bool isManual=false) -> ResourceCreateOrRetrieveResult
    create_or_retrieve(String name, String group) -> ResourceCreateOrRetrieveResult

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_create_or_retrieve__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);
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_create_or_retrieve__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;
  }
  {
    try {
      result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_or_retrieve(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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__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_create_or_retrieve__SWIG_0(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 11, "MeshManager.create_or_retrieve", 
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult MeshManager.create_or_retrieve(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.create_or_retrieve(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.create_or_retrieve(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.create_or_retrieve(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.create_or_retrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *params)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult MeshManager.create_or_retrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult MeshManager.create_or_retrieve(Ogre::String const &name, Ogre::String const &group, bool isManual)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult MeshManager.create_or_retrieve(Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.prepare

  call-seq:
    prepare(String filename, String groupName, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexBufferShadowed=true, 
    bool indexBufferShadowed=true) -> MeshPtr
    prepare(String filename, String groupName, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexBufferShadowed=true) -> MeshPtr
    prepare(String filename, String groupName, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY) -> MeshPtr
    prepare(String filename, String groupName, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY) -> MeshPtr
    prepare(String filename, String groupName) -> MeshPtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
  }
  {
    try {
      result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::MeshManager.load

  call-seq:
    load(String filename, String groupName, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexBufferShadowed=true, 
    bool indexBufferShadowed=true) -> MeshPtr
    load(String filename, String groupName, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexBufferShadowed=true) -> MeshPtr
    load(String filename, String groupName, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY) -> MeshPtr
    load(String filename, String groupName, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY) -> MeshPtr
    load(String filename, String groupName) -> MeshPtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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);
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
  }
  {
    try {
      result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::MeshManager.create_manual

  call-seq:
    create_manual(String name, String groupName, ManualResourceLoader loader=0) -> MeshPtr
    create_manual(String name, String groupName) -> MeshPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_create_manual__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);
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_create_manual__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;
  }
  {
    try {
      result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshManager_create_manual(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_create_manual__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_create_manual__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MeshManager.create_manual", 
    "    Ogre::MeshPtr MeshManager.create_manual(Ogre::String const &name, Ogre::String const &groupName, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::MeshPtr MeshManager.create_manual(Ogre::String const &name, Ogre::String const &groupName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.create_plane

  call-seq:
    create_plane(String name, String groupName, Plane plane, Real width, 
    Real height, int xsegments=1, int ysegments=1, 
    bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, Real vTile=1.0, 
    Vector3 upVector=UNIT_Y, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexShadowBuffer=true, 
    bool indexShadowBuffer=true) -> MeshPtr
    create_plane(String name, String groupName, Plane plane, Real width, 
    Real height, int xsegments=1, int ysegments=1, 
    bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, Real vTile=1.0, 
    Vector3 upVector=UNIT_Y, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexShadowBuffer=true) -> MeshPtr
    create_plane(String name, String groupName, Plane plane, Real width, 
    Real height, int xsegments=1, int ysegments=1, 
    bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, Real vTile=1.0, 
    Vector3 upVector=UNIT_Y, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY) -> MeshPtr
    create_plane(String name, String groupName, Plane plane, Real width, 
    Real height, int xsegments=1, int ysegments=1, 
    bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, Real vTile=1.0, 
    Vector3 upVector=UNIT_Y, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY) -> MeshPtr
    create_plane(String name, String groupName, Plane plane, Real width, 
    Real height, int xsegments=1, int ysegments=1, 
    bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, Real vTile=1.0, 
    Vector3 upVector=UNIT_Y) -> MeshPtr
    create_plane(String name, String groupName, Plane plane, Real width, 
    Real height, int xsegments=1, int ysegments=1, 
    bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, Real vTile=1.0) -> MeshPtr
    create_plane(String name, String groupName, Plane plane, Real width, 
    Real height, int xsegments=1, int ysegments=1, 
    bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0) -> MeshPtr
    create_plane(String name, String groupName, Plane plane, Real width, 
    Real height, int xsegments=1, int ysegments=1, 
    bool normals=true, unsigned short numTexCoordSets=1) -> MeshPtr
    create_plane(String name, String groupName, Plane plane, Real width, 
    Real height, int xsegments=1, int ysegments=1, 
    bool normals=true) -> MeshPtr
    create_plane(String name, String groupName, Plane plane, Real width, 
    Real height, int xsegments=1, int ysegments=1) -> MeshPtr
    create_plane(String name, String groupName, Plane plane, Real width, 
    Real height, int xsegments=1) -> MeshPtr
    create_plane(String name, String groupName, Plane plane, Real width, 
    Real height) -> MeshPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_create_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_plane__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);
  {
    try {
      result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_plane__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);
  {
    try {
      result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_plane__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);
  {
    try {
      result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_plane__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);
  {
    try {
      result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_plane__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);
  {
    try {
      result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_plane__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);
  {
    try {
      result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_plane__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);
  {
    try {
      result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshManager_create_plane(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_create_plane__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_create_plane__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_create_plane__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_create_plane__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_create_plane__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_create_plane__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_create_plane__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_create_plane__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_create_plane__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_create_plane__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_create_plane__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_create_plane__SWIG_0(nargs, args, self);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 18, "MeshManager.create_plane", 
    "    Ogre::MeshPtr MeshManager.create_plane(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.create_plane(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.create_plane(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.create_plane(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.create_plane(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.create_plane(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.create_plane(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.create_plane(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.create_plane(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.create_plane(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.create_plane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, int xsegments)\n"
    "    Ogre::MeshPtr MeshManager.create_plane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.create_curved_illusion_plane

  call-seq:
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1, 
    int ysegments=1, bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, 
    Real vTile=1.0, Vector3 upVector=UNIT_Y, Quaternion orientation=IDENTITY, 
    Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexShadowBuffer=true, 
    bool indexShadowBuffer=true, 
    int ySegmentsToKeep=-1) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1, 
    int ysegments=1, bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, 
    Real vTile=1.0, Vector3 upVector=UNIT_Y, Quaternion orientation=IDENTITY, 
    Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexShadowBuffer=true, 
    bool indexShadowBuffer=true) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1, 
    int ysegments=1, bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, 
    Real vTile=1.0, Vector3 upVector=UNIT_Y, Quaternion orientation=IDENTITY, 
    Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexShadowBuffer=true) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1, 
    int ysegments=1, bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, 
    Real vTile=1.0, Vector3 upVector=UNIT_Y, Quaternion orientation=IDENTITY, 
    Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1, 
    int ysegments=1, bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, 
    Real vTile=1.0, Vector3 upVector=UNIT_Y, Quaternion orientation=IDENTITY, 
    Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1, 
    int ysegments=1, bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, 
    Real vTile=1.0, Vector3 upVector=UNIT_Y, Quaternion orientation=IDENTITY) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1, 
    int ysegments=1, bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, 
    Real vTile=1.0, Vector3 upVector=UNIT_Y) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1, 
    int ysegments=1, bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0, 
    Real vTile=1.0) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1, 
    int ysegments=1, bool normals=true, unsigned short numTexCoordSets=1, 
    Real uTile=1.0) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1, 
    int ysegments=1, bool normals=true, unsigned short numTexCoordSets=1) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1, 
    int ysegments=1, bool normals=true) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1, 
    int ysegments=1) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature, int xsegments=1) -> MeshPtr
    create_curved_illusion_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real curvature) -> MeshPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_illusion_plane__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);
  {
    try {
      result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshManager_create_curved_illusion_plane(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_create_curved_illusion_plane__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_create_curved_illusion_plane__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_create_curved_illusion_plane__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_create_curved_illusion_plane__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_create_curved_illusion_plane__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_create_curved_illusion_plane__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_create_curved_illusion_plane__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_create_curved_illusion_plane__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_create_curved_illusion_plane__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_create_curved_illusion_plane__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_create_curved_illusion_plane__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_create_curved_illusion_plane__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_create_curved_illusion_plane__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_create_curved_illusion_plane__SWIG_0(nargs, args, self);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 21, "MeshManager.create_curved_illusion_plane", 
    "    Ogre::MeshPtr MeshManager.create_curved_illusion_plane(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.create_curved_illusion_plane(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.create_curved_illusion_plane(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.create_curved_illusion_plane(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.create_curved_illusion_plane(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.create_curved_illusion_plane(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.create_curved_illusion_plane(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.create_curved_illusion_plane(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.create_curved_illusion_plane(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.create_curved_illusion_plane(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.create_curved_illusion_plane(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.create_curved_illusion_plane(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.create_curved_illusion_plane(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.create_curved_illusion_plane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.create_curved_plane

  call-seq:
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real bow=0.5, int xsegments=1, 
    int ysegments=1, bool normals=false, unsigned short numTexCoordSets=1, 
    Real xTile=1.0, 
    Real yTile=1.0, Vector3 upVector=UNIT_Y, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexShadowBuffer=true, 
    bool indexShadowBuffer=true) -> MeshPtr
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real bow=0.5, int xsegments=1, 
    int ysegments=1, bool normals=false, unsigned short numTexCoordSets=1, 
    Real xTile=1.0, 
    Real yTile=1.0, Vector3 upVector=UNIT_Y, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    bool vertexShadowBuffer=true) -> MeshPtr
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real bow=0.5, int xsegments=1, 
    int ysegments=1, bool normals=false, unsigned short numTexCoordSets=1, 
    Real xTile=1.0, 
    Real yTile=1.0, Vector3 upVector=UNIT_Y, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY, 
    Usage indexBufferUsage=HBU_STATIC_WRITE_ONLY) -> MeshPtr
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real bow=0.5, int xsegments=1, 
    int ysegments=1, bool normals=false, unsigned short numTexCoordSets=1, 
    Real xTile=1.0, 
    Real yTile=1.0, Vector3 upVector=UNIT_Y, Usage vertexBufferUsage=HBU_STATIC_WRITE_ONLY) -> MeshPtr
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real bow=0.5, int xsegments=1, 
    int ysegments=1, bool normals=false, unsigned short numTexCoordSets=1, 
    Real xTile=1.0, 
    Real yTile=1.0, Vector3 upVector=UNIT_Y) -> MeshPtr
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real bow=0.5, int xsegments=1, 
    int ysegments=1, bool normals=false, unsigned short numTexCoordSets=1, 
    Real xTile=1.0, 
    Real yTile=1.0) -> MeshPtr
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real bow=0.5, int xsegments=1, 
    int ysegments=1, bool normals=false, unsigned short numTexCoordSets=1, 
    Real xTile=1.0) -> MeshPtr
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real bow=0.5, int xsegments=1, 
    int ysegments=1, bool normals=false, unsigned short numTexCoordSets=1) -> MeshPtr
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real bow=0.5, int xsegments=1, 
    int ysegments=1, bool normals=false) -> MeshPtr
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real bow=0.5, int xsegments=1, 
    int ysegments=1) -> MeshPtr
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real bow=0.5, int xsegments=1) -> MeshPtr
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height, Real bow=0.5) -> MeshPtr
    create_curved_plane(String name, String groupName, Plane plane, Real width, 
    Real height) -> MeshPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_create_curved_plane__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);
  {
    try {
      result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshManager_create_curved_plane(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_create_curved_plane__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_create_curved_plane__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_create_curved_plane__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_create_curved_plane__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_create_curved_plane__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_create_curved_plane__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_create_curved_plane__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_create_curved_plane__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_create_curved_plane__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_create_curved_plane__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_create_curved_plane__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_create_curved_plane__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_create_curved_plane__SWIG_0(nargs, args, self);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 19, "MeshManager.create_curved_plane", 
    "    Ogre::MeshPtr MeshManager.create_curved_plane(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.create_curved_plane(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.create_curved_plane(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.create_curved_plane(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.create_curved_plane(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.create_curved_plane(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.create_curved_plane(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.create_curved_plane(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.create_curved_plane(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.create_curved_plane(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.create_curved_plane(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.create_curved_plane(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.create_curved_plane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.create_bezier_patch

  call-seq:
    create_bezier_patch(String name, String groupName, void controlPointBuffer, 
    VertexDeclaration declaration, size_t width, 
    size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL, 
    VisibleSide visibleSide=VS_FRONT, Usage vbUsage=HBU_STATIC_WRITE_ONLY, 
    Usage ibUsage=HBU_DYNAMIC_WRITE_ONLY, 
    bool vbUseShadow=true, 
    bool ibUseShadow=true) -> PatchMeshPtr
    create_bezier_patch(String name, String groupName, void controlPointBuffer, 
    VertexDeclaration declaration, size_t width, 
    size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL, 
    VisibleSide visibleSide=VS_FRONT, Usage vbUsage=HBU_STATIC_WRITE_ONLY, 
    Usage ibUsage=HBU_DYNAMIC_WRITE_ONLY, 
    bool vbUseShadow=true) -> PatchMeshPtr
    create_bezier_patch(String name, String groupName, void controlPointBuffer, 
    VertexDeclaration declaration, size_t width, 
    size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL, 
    VisibleSide visibleSide=VS_FRONT, Usage vbUsage=HBU_STATIC_WRITE_ONLY, 
    Usage ibUsage=HBU_DYNAMIC_WRITE_ONLY) -> PatchMeshPtr
    create_bezier_patch(String name, String groupName, void controlPointBuffer, 
    VertexDeclaration declaration, size_t width, 
    size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL, 
    VisibleSide visibleSide=VS_FRONT, Usage vbUsage=HBU_STATIC_WRITE_ONLY) -> PatchMeshPtr
    create_bezier_patch(String name, String groupName, void controlPointBuffer, 
    VertexDeclaration declaration, size_t width, 
    size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL, 
    VisibleSide visibleSide=VS_FRONT) -> PatchMeshPtr
    create_bezier_patch(String name, String groupName, void controlPointBuffer, 
    VertexDeclaration declaration, size_t width, 
    size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL, 
    size_t vMaxSubdivisionLevel=AUTO_LEVEL) -> PatchMeshPtr
    create_bezier_patch(String name, String groupName, void controlPointBuffer, 
    VertexDeclaration declaration, size_t width, 
    size_t height, size_t uMaxSubdivisionLevel=AUTO_LEVEL) -> PatchMeshPtr
    create_bezier_patch(String name, String groupName, void controlPointBuffer, 
    VertexDeclaration declaration, size_t width, 
    size_t height) -> PatchMeshPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_create_bezier_patch__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);
  {
    try {
      result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_bezier_patch__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);
  {
    try {
      result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_bezier_patch__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);
  {
    try {
      result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_bezier_patch__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);
  {
    try {
      result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_bezier_patch__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);
  {
    try {
      result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_bezier_patch__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);
  {
    try {
      result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_bezier_patch__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);
  {
    try {
      result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_bezier_patch__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);
  {
    try {
      result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_bezier_patch(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_create_bezier_patch__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_create_bezier_patch__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_create_bezier_patch__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_create_bezier_patch__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_create_bezier_patch__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_create_bezier_patch__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_create_bezier_patch__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_create_bezier_patch__SWIG_0(nargs, args, self);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 15, "MeshManager.create_bezier_patch", 
    "    Ogre::PatchMeshPtr MeshManager.create_bezier_patch(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.create_bezier_patch(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.create_bezier_patch(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.create_bezier_patch(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.create_bezier_patch(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.create_bezier_patch(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.create_bezier_patch(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.create_bezier_patch(Ogre::String const &name, Ogre::String const &groupName, void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.set_prepare_all_meshes_for_shadow_volumes

  call-seq:
    set_prepare_all_meshes_for_shadow_volumes(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_set_prepare_all_meshes_for_shadow_volumes(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);
  {
    try {
      (arg1)->setPrepareAllMeshesForShadowVolumes(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.get_prepare_all_meshes_for_shadow_volumes

  call-seq:
    get_prepare_all_meshes_for_shadow_volumes -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_get_prepare_all_meshes_for_shadow_volumes(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);
  {
    try {
      result = (bool)(arg1)->getPrepareAllMeshesForShadowVolumes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.get_singleton

  call-seq:
    get_singleton -> MeshManager

A class method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::MeshManager *) &Ogre::MeshManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> MeshManager

A class method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::MeshManager *)Ogre::MeshManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.get_bounds_padding_factor

  call-seq:
    get_bounds_padding_factor -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_get_bounds_padding_factor(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getBoundsPaddingFactor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.set_bounds_padding_factor

  call-seq:
    set_bounds_padding_factor(Real paddingFactor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_set_bounds_padding_factor(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);
  {
    try {
      (arg1)->setBoundsPaddingFactor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.set_listener

  call-seq:
    set_listener(MeshSerializerListener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_set_listener(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);
  {
    try {
      (arg1)->setListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.get_listener

  call-seq:
    get_listener -> MeshSerializerListener

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_get_listener(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);
  {
    try {
      result = (Ogre::MeshSerializerListener *)(arg1)->getListener();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshSerializerListener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshManager.load_resource

  call-seq:
    load_resource(Resource res)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshManager_load_resource(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);
  {
    try {
      (arg1)->loadResource(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::MeshSerializer < Ogre::Ogre::Serializer

  Proxy of C++ Ogre::MeshSerializer class


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


/*
  Document-method: Ogre::MeshSerializer.new

  call-seq:
    MeshSerializer.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::MeshSerializer *)new Ogre::MeshSerializer();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MeshSerializer(Ogre::MeshSerializer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::MeshSerializer.export_mesh

  call-seq:
    export_mesh(Mesh pMesh, String filename, Endian endianMode=ENDIAN_NATIVE)
    export_mesh(Mesh pMesh, String filename)
    export_mesh(Mesh pMesh, String filename, MeshVersion version, Endian endianMode=ENDIAN_NATIVE)
    export_mesh(Mesh pMesh, String filename, MeshVersion version)
    export_mesh(Mesh pMesh, DataStreamPtr stream, Endian endianMode=ENDIAN_NATIVE)
    export_mesh(Mesh pMesh, DataStreamPtr stream)
    export_mesh(Mesh pMesh, DataStreamPtr stream, MeshVersion version, 
    Endian endianMode=ENDIAN_NATIVE)
    export_mesh(Mesh pMesh, DataStreamPtr stream, MeshVersion version)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSerializer_export_mesh__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);
  {
    try {
      (arg1)->exportMesh((Ogre::Mesh const *)arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_export_mesh__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;
  }
  {
    try {
      (arg1)->exportMesh((Ogre::Mesh const *)arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_export_mesh__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);
  {
    try {
      (arg1)->exportMesh((Ogre::Mesh const *)arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_export_mesh__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);
  {
    try {
      (arg1)->exportMesh((Ogre::Mesh const *)arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_export_mesh__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);
  {
    try {
      (arg1)->exportMesh((Ogre::Mesh const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_export_mesh__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));
    }
  }
  {
    try {
      (arg1)->exportMesh((Ogre::Mesh const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_export_mesh__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);
  {
    try {
      (arg1)->exportMesh((Ogre::Mesh const *)arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_export_mesh__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);
  {
    try {
      (arg1)->exportMesh((Ogre::Mesh const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSerializer_export_mesh(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_export_mesh__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_export_mesh__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_export_mesh__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_export_mesh__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_export_mesh__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_export_mesh__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_export_mesh__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_export_mesh__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "MeshSerializer.export_mesh", 
    "    void MeshSerializer.export_mesh(Ogre::Mesh const *pMesh, Ogre::String const &filename, Ogre::Serializer::Endian endianMode)\n"
    "    void MeshSerializer.export_mesh(Ogre::Mesh const *pMesh, Ogre::String const &filename)\n"
    "    void MeshSerializer.export_mesh(Ogre::Mesh const *pMesh, Ogre::String const &filename, Ogre::MeshVersion version, Ogre::Serializer::Endian endianMode)\n"
    "    void MeshSerializer.export_mesh(Ogre::Mesh const *pMesh, Ogre::String const &filename, Ogre::MeshVersion version)\n"
    "    void MeshSerializer.export_mesh(Ogre::Mesh const *pMesh, Ogre::DataStreamPtr stream, Ogre::Serializer::Endian endianMode)\n"
    "    void MeshSerializer.export_mesh(Ogre::Mesh const *pMesh, Ogre::DataStreamPtr stream)\n"
    "    void MeshSerializer.export_mesh(Ogre::Mesh const *pMesh, Ogre::DataStreamPtr stream, Ogre::MeshVersion version, Ogre::Serializer::Endian endianMode)\n"
    "    void MeshSerializer.export_mesh(Ogre::Mesh const *pMesh, Ogre::DataStreamPtr stream, Ogre::MeshVersion version)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::MeshSerializer.import_mesh

  call-seq:
    import_mesh(DataStreamPtr stream, Mesh pDest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSerializer_import_mesh(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);
  {
    try {
      (arg1)->importMesh(*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshSerializer.set_listener

  call-seq:
    set_listener(MeshSerializerListener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSerializer_set_listener(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);
  {
    try {
      (arg1)->setListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshSerializer.get_listener

  call-seq:
    get_listener -> MeshSerializerListener

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSerializer_get_listener(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);
  {
    try {
      result = (Ogre::MeshSerializerListener *)(arg1)->getListener();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshSerializerListener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::MeshSerializerListener

  Proxy of C++ Ogre::MeshSerializerListener class


*/
swig_class SwigClassMeshSerializerListener;

SWIGINTERN void
free_Ogre_MeshSerializerListener(Ogre::MeshSerializerListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::MeshSerializerListener.process_material_name

  call-seq:
    process_material_name(Mesh mesh, String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSerializerListener_process_material_name(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);
  {
    try {
      (arg1)->processMaterialName(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MeshSerializerListener.process_skeleton_name

  call-seq:
    process_skeleton_name(Mesh mesh, String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_MeshSerializerListener_process_skeleton_name(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);
  {
    try {
      (arg1)->processSkeletonName(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::OptimisedUtil

  Proxy of C++ Ogre::OptimisedUtil class


*/
swig_class SwigClassOptimisedUtil;

SWIGINTERN void
free_Ogre_OptimisedUtil(Ogre::OptimisedUtil *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::OptimisedUtil.get_implementation

  call-seq:
    get_implementation -> OptimisedUtil

A class method.

*/
SWIGINTERN VALUE
_wrap_OptimisedUtil_get_implementation(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;
  }
  {
    try {
      result = (Ogre::OptimisedUtil *)Ogre::OptimisedUtil::getImplementation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OptimisedUtil, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OptimisedUtil.software_vertex_skinning

  call-seq:
    software_vertex_skinning(float srcPosPtr, float destPosPtr, float srcNormPtr, 
    float destNormPtr, float blendWeightPtr, unsigned char blendIndexPtr, 
    Matrix4 blendMatrices, 
    size_t srcPosStride, size_t destPosStride, 
    size_t srcNormStride, size_t destNormStride, 
    size_t blendWeightStride, size_t blendIndexStride, 
    size_t numWeightsPerVertex, size_t numVertices)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OptimisedUtil_software_vertex_skinning(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);
  {
    try {
      (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);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OptimisedUtil.software_vertex_morph

  call-seq:
    software_vertex_morph(Real t, float srcPos1, float srcPos2, float dstPos, 
    size_t pos1VSize, size_t pos2VSize, size_t dstVSize, 
    size_t numVertices, bool morphNormals)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OptimisedUtil_software_vertex_morph(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);
  {
    try {
      (arg1)->softwareVertexMorph(arg2,(float const *)arg3,(float const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OptimisedUtil.concatenate_affine_matrices

  call-seq:
    concatenate_affine_matrices(Matrix4 baseMatrix, Matrix4 srcMatrices, Matrix4 dstMatrices, 
    size_t numMatrices)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OptimisedUtil_concatenate_affine_matrices(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);
  {
    try {
      (arg1)->concatenateAffineMatrices((Ogre::Matrix4 const &)*arg2,(Ogre::Matrix4 const *)arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OptimisedUtil.calculate_face_normals

  call-seq:
    calculate_face_normals(float positions, Triangle triangles, Vector4 faceNormals, 
    size_t numTriangles)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OptimisedUtil_calculate_face_normals(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);
  {
    try {
      (arg1)->calculateFaceNormals((float const *)arg2,(Ogre::EdgeData::Triangle const *)arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OptimisedUtil.calculate_light_facing

  call-seq:
    calculate_light_facing(Vector4 lightPos, Vector4 faceNormals, char lightFacings, 
    size_t numFaces)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OptimisedUtil_calculate_light_facing(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);
  {
    try {
      (arg1)->calculateLightFacing((Ogre::Vector4 const &)*arg2,(Ogre::Vector4 const *)arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
fail:
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}



/*
  Document-method: Ogre::OptimisedUtil.extrude_vertices

  call-seq:
    extrude_vertices(Vector4 lightPos, Real extrudeDist, float srcPositions, 
    float destPositions, size_t numVertices)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OptimisedUtil_extrude_vertices(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);
  {
    try {
      (arg1)->extrudeVertices((Ogre::Vector4 const &)*arg2,arg3,(float const *)arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Overlay

  Proxy of C++ Ogre::Overlay class


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


/*
  Document-method: Ogre::Overlay.new

  call-seq:
    Overlay.new(String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Overlay *)new Ogre::Overlay((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::Overlay.get_child

  call-seq:
    get_child(String name) -> OverlayContainer

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_get_child(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;
  }
  {
    try {
      result = (Ogre::OverlayContainer *)(arg1)->getChild((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Overlay const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.set_zorder

  call-seq:
    set_zorder(ushort zorder)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_set_zorder(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);
  {
    try {
      (arg1)->setZOrder(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.get_zorder

  call-seq:
    get_zorder -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_get_zorder(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::Overlay const *)arg1)->getZOrder();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.is_visible

  call-seq:
    is_visible -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_is_visible(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);
  {
    try {
      result = (bool)((Ogre::Overlay const *)arg1)->isVisible();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.is_initialised

  call-seq:
    is_initialised -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_is_initialised(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);
  {
    try {
      result = (bool)((Ogre::Overlay const *)arg1)->isInitialised();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.show

  call-seq:
    show

An instance method.

*/
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);
  {
    try {
      (arg1)->show();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.hide

  call-seq:
    hide

An instance method.

*/
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);
  {
    try {
      (arg1)->hide();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.add_2d

  call-seq:
    add_2d(OverlayContainer cont)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_add_2d(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);
  {
    try {
      (arg1)->add2D(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.remove_2d

  call-seq:
    remove_2d(OverlayContainer cont)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_remove_2d(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);
  {
    try {
      (arg1)->remove2D(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.add_3d

  call-seq:
    add_3d(SceneNode node)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_add_3d(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);
  {
    try {
      (arg1)->add3D(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.remove_3d

  call-seq:
    remove_3d(SceneNode node)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_remove_3d(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);
  {
    try {
      (arg1)->remove3D(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.set_scroll

  call-seq:
    set_scroll(Real x, Real y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_set_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 *","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);
  {
    try {
      (arg1)->setScroll(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.get_scroll_x

  call-seq:
    get_scroll_x -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_get_scroll_x(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Overlay const *)arg1)->getScrollX();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.get_scroll_y

  call-seq:
    get_scroll_y -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_get_scroll_y(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Overlay const *)arg1)->getScrollY();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.scroll

  call-seq:
    scroll(Real xoff, Real yoff)

An instance method.

*/
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);
  {
    try {
      (arg1)->scroll(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.set_rotate

  call-seq:
    set_rotate(Radian angle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_set_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 *","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);
  {
    try {
      (arg1)->setRotate((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.get_rotate

  call-seq:
    get_rotate -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_get_rotate(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);
  {
    try {
      result = (Ogre::Radian *) &((Ogre::Overlay const *)arg1)->getRotate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.rotate

  call-seq:
    rotate(Radian angle)

An instance method.

*/
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);
  {
    try {
      (arg1)->rotate((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.set_scale

  call-seq:
    set_scale(Real x, Real y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_set_scale(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);
  {
    try {
      (arg1)->setScale(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.get_scale_x

  call-seq:
    get_scale_x -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_get_scale_x(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Overlay const *)arg1)->getScaleX();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.get_scale_y

  call-seq:
    get_scale_y -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_get_scale_y(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Overlay const *)arg1)->getScaleY();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay._get_world_transforms

  call-seq:
    _get_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay__get_world_transforms(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);
  {
    try {
      ((Ogre::Overlay const *)arg1)->_getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay._find_visible_objects

  call-seq:
    _find_visible_objects(Camera cam, RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay__find_visible_objects(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);
  {
    try {
      (arg1)->_findVisibleObjects(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.find_element_at

  call-seq:
    find_element_at(Real x, Real y) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_find_element_at(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);
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->findElementAt(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.get_2delements_iterator

  call-seq:
    get_2delements_iterator -> Overlay2DElementsIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_get_2delements_iterator(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);
  {
    try {
      result = (arg1)->get2DElementsIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Overlay.get_origin

  call-seq:
    get_origin -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay_get_origin(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Overlay const *)arg1)->getOrigin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay._notify_origin

  call-seq:
    _notify_origin(String origin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Overlay__notify_origin(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;
  }
  {
    try {
      (arg1)->_notifyOrigin((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-class: Ogre::TextAreaOverlayElement < Ogre::Ogre::OverlayElement

  Proxy of C++ Ogre::TextAreaOverlayElement class


*/
swig_class SwigClassTextAreaOverlayElement;


/*
  Document-method: Ogre::Alignment.Left

  call-seq:
    Left -> int

A class method.

*/

/*
  Document-method: Ogre::Alignment.Right

  call-seq:
    Right -> int

A class method.

*/

/*
  Document-method: Ogre::Alignment.Center

  call-seq:
    Center -> int

A class method.

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


/*
  Document-method: Ogre::TextAreaOverlayElement.new

  call-seq:
    TextAreaOverlayElement.new(String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TextAreaOverlayElement *)new Ogre::TextAreaOverlayElement((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::TextAreaOverlayElement.initialise

  call-seq:
    initialise

An instance method.

*/
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);
  {
    try {
      (arg1)->initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.set_caption

  call-seq:
    set_caption(DisplayString text)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_set_caption(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);
  {
    try {
      (arg1)->setCaption((Ogre::DisplayString const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.set_char_height

  call-seq:
    set_char_height(Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_set_char_height(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);
  {
    try {
      (arg1)->setCharHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.get_char_height

  call-seq:
    get_char_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_get_char_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TextAreaOverlayElement const *)arg1)->getCharHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.set_space_width

  call-seq:
    set_space_width(Real width)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_set_space_width(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);
  {
    try {
      (arg1)->setSpaceWidth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.get_space_width

  call-seq:
    get_space_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_get_space_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TextAreaOverlayElement const *)arg1)->getSpaceWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.set_font_name

  call-seq:
    set_font_name(String font)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_set_font_name(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;
  }
  {
    try {
      (arg1)->setFontName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.get_font_name

  call-seq:
    get_font_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_get_font_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::TextAreaOverlayElement const *)arg1)->getFontName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.get_type_name

  call-seq:
    get_type_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_get_type_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::TextAreaOverlayElement const *)arg1)->getTypeName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::TextAreaOverlayElement const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.get_render_operation

  call-seq:
    get_render_operation(RenderOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_get_render_operation(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);
  {
    try {
      (arg1)->getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.set_material_name

  call-seq:
    set_material_name(String matName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_set_material_name(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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.set_colour

  call-seq:
    set_colour(ColourValue col)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_set_colour(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);
  {
    try {
      (arg1)->setColour((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.get_colour

  call-seq:
    get_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_get_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::TextAreaOverlayElement const *)arg1)->getColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.set_colour_bottom

  call-seq:
    set_colour_bottom(ColourValue col)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_set_colour_bottom(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);
  {
    try {
      (arg1)->setColourBottom((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.get_colour_bottom

  call-seq:
    get_colour_bottom -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_get_colour_bottom(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::TextAreaOverlayElement const *)arg1)->getColourBottom();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.set_colour_top

  call-seq:
    set_colour_top(ColourValue col)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_set_colour_top(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);
  {
    try {
      (arg1)->setColourTop((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.get_colour_top

  call-seq:
    get_colour_top -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_get_colour_top(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::TextAreaOverlayElement const *)arg1)->getColourTop();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.set_alignment

  call-seq:
    set_alignment(Alignment a)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_set_alignment(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);
  {
    try {
      (arg1)->setAlignment(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.get_alignment

  call-seq:
    get_alignment -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_get_alignment(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);
  {
    try {
      result = (Ogre::TextAreaOverlayElement::Alignment)((Ogre::TextAreaOverlayElement const *)arg1)->getAlignment();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement.set_metrics_mode

  call-seq:
    set_metrics_mode(GuiMetricsMode gmm)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_set_metrics_mode(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);
  {
    try {
      (arg1)->setMetricsMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElement._update

  call-seq:
    _update

An instance method.

*/
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);
  {
    try {
      (arg1)->_update();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::OverlayElementFactory

  Proxy of C++ Ogre::OverlayElementFactory class


*/
swig_class SwigClassOverlayElementFactory;

SWIGINTERN void
free_Ogre_OverlayElementFactory(Ogre::OverlayElementFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::OverlayElementFactory.create_overlay_element

  call-seq:
    create_overlay_element(String instanceName) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElementFactory_create_overlay_element(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;
  }
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->createOverlayElement((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElementFactory.destroy_overlay_element

  call-seq:
    destroy_overlay_element(OverlayElement pElement)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElementFactory_destroy_overlay_element(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);
  {
    try {
      (arg1)->destroyOverlayElement(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElementFactory.get_type_name

  call-seq:
    get_type_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayElementFactory_get_type_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::OverlayElementFactory const *)arg1)->getTypeName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PanelOverlayElementFactory < Ogre::Ogre::OverlayElementFactory

  Proxy of C++ Ogre::PanelOverlayElementFactory class


*/
swig_class SwigClassPanelOverlayElementFactory;


/*
  Document-method: Ogre::PanelOverlayElementFactory.create_overlay_element

  call-seq:
    create_overlay_element(String instanceName) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElementFactory_create_overlay_element(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;
  }
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->createOverlayElement((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PanelOverlayElementFactory.get_type_name

  call-seq:
    get_type_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PanelOverlayElementFactory_get_type_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::PanelOverlayElementFactory const *)arg1)->getTypeName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::PanelOverlayElementFactory.new

  call-seq:
    PanelOverlayElementFactory.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PanelOverlayElementFactory *)new Ogre::PanelOverlayElementFactory();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PanelOverlayElementFactory(Ogre::PanelOverlayElementFactory *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::BorderPanelOverlayElementFactory < Ogre::Ogre::OverlayElementFactory

  Proxy of C++ Ogre::BorderPanelOverlayElementFactory class


*/
swig_class SwigClassBorderPanelOverlayElementFactory;


/*
  Document-method: Ogre::BorderPanelOverlayElementFactory.create_overlay_element

  call-seq:
    create_overlay_element(String instanceName) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElementFactory_create_overlay_element(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;
  }
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->createOverlayElement((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::BorderPanelOverlayElementFactory.get_type_name

  call-seq:
    get_type_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_BorderPanelOverlayElementFactory_get_type_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::BorderPanelOverlayElementFactory const *)arg1)->getTypeName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::BorderPanelOverlayElementFactory.new

  call-seq:
    BorderPanelOverlayElementFactory.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::BorderPanelOverlayElementFactory *)new Ogre::BorderPanelOverlayElementFactory();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_BorderPanelOverlayElementFactory(Ogre::BorderPanelOverlayElementFactory *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::TextAreaOverlayElementFactory < Ogre::Ogre::OverlayElementFactory

  Proxy of C++ Ogre::TextAreaOverlayElementFactory class


*/
swig_class SwigClassTextAreaOverlayElementFactory;


/*
  Document-method: Ogre::TextAreaOverlayElementFactory.create_overlay_element

  call-seq:
    create_overlay_element(String instanceName) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElementFactory_create_overlay_element(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;
  }
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->createOverlayElement((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::TextAreaOverlayElementFactory.get_type_name

  call-seq:
    get_type_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TextAreaOverlayElementFactory_get_type_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::TextAreaOverlayElementFactory const *)arg1)->getTypeName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::TextAreaOverlayElementFactory.new

  call-seq:
    TextAreaOverlayElementFactory.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TextAreaOverlayElementFactory *)new Ogre::TextAreaOverlayElementFactory();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TextAreaOverlayElementFactory(Ogre::TextAreaOverlayElementFactory *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::OverlayManager < Ogre::Ogre::ScriptLoader

  Proxy of C++ Ogre::OverlayManager class


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


/*
  Document-method: Ogre::OverlayManager.new

  call-seq:
    OverlayManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::OverlayManager *)new Ogre::OverlayManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.get_script_patterns

  call-seq:
    get_script_patterns -> StringVector

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_script_patterns(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);
  {
    try {
      result = (Ogre::StringVector *) &((Ogre::OverlayManager const *)arg1)->getScriptPatterns();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.parse_script

  call-seq:
    parse_script(DataStreamPtr stream, String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_parse_script(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;
  }
  {
    try {
      (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.get_loading_order

  call-seq:
    get_loading_order -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_loading_order(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);
  {
    try {
      result = (Ogre::Real)((Ogre::OverlayManager const *)arg1)->getLoadingOrder();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.create

  call-seq:
    create(String name) -> Overlay

An instance method.

*/
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;
  }
  {
    try {
      result = (Ogre::Overlay *)(arg1)->create((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Overlay, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.get_by_name

  call-seq:
    get_by_name(String name) -> Overlay

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_by_name(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;
  }
  {
    try {
      result = (Ogre::Overlay *)(arg1)->getByName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Overlay, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.destroy

  call-seq:
    destroy(String name)
    destroy(Overlay overlay)

An instance method.

*/
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;
  }
  {
    try {
      (arg1)->destroy((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->destroy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::OverlayManager.destroy_all

  call-seq:
    destroy_all

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_destroy_all(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);
  {
    try {
      (arg1)->destroyAll();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.get_overlay_iterator

  call-seq:
    get_overlay_iterator -> OverlayMapIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_overlay_iterator(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);
  {
    try {
      result = (arg1)->getOverlayIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::OverlayManager._queue_overlays_for_rendering

  call-seq:
    _queue_overlays_for_rendering(Camera cam, RenderQueue pQueue, Viewport vp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager__queue_overlays_for_rendering(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);
  {
    try {
      (arg1)->_queueOverlaysForRendering(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.has_viewport_changed

  call-seq:
    has_viewport_changed -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_has_viewport_changed(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);
  {
    try {
      result = (bool)((Ogre::OverlayManager const *)arg1)->hasViewportChanged();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.get_viewport_height

  call-seq:
    get_viewport_height -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_viewport_height(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);
  {
    try {
      result = (int)((Ogre::OverlayManager const *)arg1)->getViewportHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.get_viewport_width

  call-seq:
    get_viewport_width -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_viewport_width(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);
  {
    try {
      result = (int)((Ogre::OverlayManager const *)arg1)->getViewportWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.get_viewport_aspect_ratio

  call-seq:
    get_viewport_aspect_ratio -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_viewport_aspect_ratio(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);
  {
    try {
      result = (Ogre::Real)((Ogre::OverlayManager const *)arg1)->getViewportAspectRatio();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.get_viewport_orientation_mode

  call-seq:
    get_viewport_orientation_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_viewport_orientation_mode(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);
  {
    try {
      result = (Ogre::OrientationMode)((Ogre::OverlayManager const *)arg1)->getViewportOrientationMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.create_overlay_element

  call-seq:
    create_overlay_element(String typeName, String instanceName, bool isTemplate=false) -> OverlayElement
    create_overlay_element(String typeName, String instanceName) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_create_overlay_element__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);
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->createOverlayElement((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_overlay_element__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;
  }
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->createOverlayElement((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_create_overlay_element(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_create_overlay_element__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_create_overlay_element__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "OverlayManager.create_overlay_element", 
    "    Ogre::OverlayElement * OverlayManager.create_overlay_element(Ogre::String const &typeName, Ogre::String const &instanceName, bool isTemplate)\n"
    "    Ogre::OverlayElement * OverlayManager.create_overlay_element(Ogre::String const &typeName, Ogre::String const &instanceName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.get_overlay_element

  call-seq:
    get_overlay_element(String name, bool isTemplate=false) -> OverlayElement
    get_overlay_element(String name) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_overlay_element__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);
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->getOverlayElement((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_overlay_element__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;
  }
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->getOverlayElement((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_overlay_element(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_get_overlay_element__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_get_overlay_element__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "OverlayManager.get_overlay_element", 
    "    Ogre::OverlayElement * OverlayManager.get_overlay_element(Ogre::String const &name, bool isTemplate)\n"
    "    Ogre::OverlayElement * OverlayManager.get_overlay_element(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.has_overlay_element

  call-seq:
    has_overlay_element(String name, bool isTemplate=false) -> bool
    has_overlay_element(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_has_overlay_element__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);
  {
    try {
      result = (bool)(arg1)->hasOverlayElement((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_has_overlay_element__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;
  }
  {
    try {
      result = (bool)(arg1)->hasOverlayElement((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_has_overlay_element(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_has_overlay_element__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_has_overlay_element__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "OverlayManager.has_overlay_element", 
    "    bool OverlayManager.has_overlay_element(Ogre::String const &name, bool isTemplate)\n"
    "    bool OverlayManager.has_overlay_element(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.destroy_overlay_element

  call-seq:
    destroy_overlay_element(String instanceName, bool isTemplate=false)
    destroy_overlay_element(String instanceName)
    destroy_overlay_element(OverlayElement pInstance, bool isTemplate=false)
    destroy_overlay_element(OverlayElement pInstance)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_destroy_overlay_element__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);
  {
    try {
      (arg1)->destroyOverlayElement((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroy_overlay_element__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;
  }
  {
    try {
      (arg1)->destroyOverlayElement((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroy_overlay_element__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);
  {
    try {
      (arg1)->destroyOverlayElement(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroy_overlay_element__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);
  {
    try {
      (arg1)->destroyOverlayElement(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayManager_destroy_overlay_element(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_destroy_overlay_element__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_destroy_overlay_element__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_destroy_overlay_element__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_destroy_overlay_element__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "OverlayManager.destroy_overlay_element", 
    "    void OverlayManager.destroy_overlay_element(Ogre::String const &instanceName, bool isTemplate)\n"
    "    void OverlayManager.destroy_overlay_element(Ogre::String const &instanceName)\n"
    "    void OverlayManager.destroy_overlay_element(Ogre::OverlayElement *pInstance, bool isTemplate)\n"
    "    void OverlayManager.destroy_overlay_element(Ogre::OverlayElement *pInstance)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.destroy_all_overlay_elements

  call-seq:
    destroy_all_overlay_elements(bool isTemplate=false)
    destroy_all_overlay_elements

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_destroy_all_overlay_elements__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);
  {
    try {
      (arg1)->destroyAllOverlayElements(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroy_all_overlay_elements__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);
  {
    try {
      (arg1)->destroyAllOverlayElements();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayManager_destroy_all_overlay_elements(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_destroy_all_overlay_elements__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_destroy_all_overlay_elements__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "OverlayManager.destroy_all_overlay_elements", 
    "    void OverlayManager.destroy_all_overlay_elements(bool isTemplate)\n"
    "    void OverlayManager.destroy_all_overlay_elements()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.add_overlay_element_factory

  call-seq:
    add_overlay_element_factory(OverlayElementFactory elemFactory)

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_add_overlay_element_factory(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);
  {
    try {
      (arg1)->addOverlayElementFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.get_overlay_element_factory_map

  call-seq:
    get_overlay_element_factory_map -> FactoryMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_overlay_element_factory_map(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);
  {
    try {
      result = (Ogre::OverlayManager::FactoryMap *) &((Ogre::OverlayManager const *)arg1)->getOverlayElementFactoryMap();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::OverlayManager.create_overlay_element_from_template

  call-seq:
    create_overlay_element_from_template(String templateName, String typeName, String instanceName, 
    bool isTemplate=false) -> OverlayElement
    create_overlay_element_from_template(String templateName, String typeName, String instanceName) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_create_overlay_element_from_template__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);
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->createOverlayElementFromTemplate((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_overlay_element_from_template__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;
  }
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->createOverlayElementFromTemplate((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_overlay_element_from_template(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_create_overlay_element_from_template__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_create_overlay_element_from_template__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "OverlayManager.create_overlay_element_from_template", 
    "    Ogre::OverlayElement * OverlayManager.create_overlay_element_from_template(Ogre::String const &templateName, Ogre::String const &typeName, Ogre::String const &instanceName, bool isTemplate)\n"
    "    Ogre::OverlayElement * OverlayManager.create_overlay_element_from_template(Ogre::String const &templateName, Ogre::String const &typeName, Ogre::String const &instanceName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.clone_overlay_element_from_template

  call-seq:
    clone_overlay_element_from_template(String templateName, String instanceName) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_clone_overlay_element_from_template(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;
  }
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->cloneOverlayElementFromTemplate((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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;
}



/*
  Document-method: Ogre::OverlayManager.create_overlay_element_from_factory

  call-seq:
    create_overlay_element_from_factory(String typeName, String instanceName) -> OverlayElement

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_create_overlay_element_from_factory(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;
  }
  {
    try {
      result = (Ogre::OverlayElement *)(arg1)->createOverlayElementFromFactory((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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;
}



/*
  Document-method: Ogre::OverlayManager.get_template_iterator

  call-seq:
    get_template_iterator -> TemplateIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_template_iterator(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);
  {
    try {
      result = (arg1)->getTemplateIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::OverlayManager.is_template

  call-seq:
    is_template(String strName) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_is_template(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;
  }
  {
    try {
      result = (bool)((Ogre::OverlayManager const *)arg1)->isTemplate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.get_singleton

  call-seq:
    get_singleton -> OverlayManager

A class method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::OverlayManager *) &Ogre::OverlayManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> OverlayManager

A class method.

*/
SWIGINTERN VALUE
_wrap_OverlayManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::OverlayManager *)Ogre::OverlayManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ParticleVisualData

  Proxy of C++ Ogre::ParticleVisualData class


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


/*
  Document-method: Ogre::ParticleVisualData.new

  call-seq:
    ParticleVisualData.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ParticleVisualData *)new Ogre::ParticleVisualData();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleVisualData(Ogre::ParticleVisualData *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::Particle

  Proxy of C++ Ogre::Particle class


*/
swig_class SwigClassParticle;


/*
  Document-method: Ogre::ParticleType.Visual

  call-seq:
    Visual -> int

A class method.

*/

/*
  Document-method: Ogre::ParticleType.Emitter

  call-seq:
    Emitter -> int

A class method.

*/

/*
  Document-method: Ogre::Particle.mOwnDimensions

  call-seq:
    mOwnDimensions -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::Particle.mOwnDimensions=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::Particle.mWidth

  call-seq:
    mWidth -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Particle.mWidth=

  call-seq:
    mWidth=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::Particle.mHeight

  call-seq:
    mHeight -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Particle.mHeight=

  call-seq:
    mHeight=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::Particle.rotation

  call-seq:
    rotation -> Radian

Get value of attribute.

*/

/*
  Document-method: Ogre::Particle.rotation=

  call-seq:
    rotation=(x) -> Radian

Set new value for attribute.

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



/*
  Document-method: Ogre::Particle.position

  call-seq:
    position -> Vector3

Get value of attribute.

*/

/*
  Document-method: Ogre::Particle.position=

  call-seq:
    position=(x) -> Vector3

Set new value for attribute.

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



/*
  Document-method: Ogre::Particle.direction

  call-seq:
    direction -> Vector3

Get value of attribute.

*/

/*
  Document-method: Ogre::Particle.direction=

  call-seq:
    direction=(x) -> Vector3

Set new value for attribute.

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



/*
  Document-method: Ogre::Particle.colour

  call-seq:
    colour -> ColourValue

Get value of attribute.

*/

/*
  Document-method: Ogre::Particle.colour=

  call-seq:
    colour=(x) -> ColourValue

Set new value for attribute.

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



/*
  Document-method: Ogre::Particle.timeToLive

  call-seq:
    timeToLive -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Particle.timeToLive=

  call-seq:
    timeToLive=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::Particle.totalTimeToLive

  call-seq:
    totalTimeToLive -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::Particle.totalTimeToLive=

  call-seq:
    totalTimeToLive=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::Particle.rotationSpeed

  call-seq:
    rotationSpeed -> Radian

Get value of attribute.

*/

/*
  Document-method: Ogre::Particle.rotationSpeed=

  call-seq:
    rotationSpeed=(x) -> Radian

Set new value for attribute.

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



/*
  Document-method: Ogre::Particle.particleType

  call-seq:
    particleType -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::Particle.particleType=

  call-seq:
    particleType=(x) -> int

Set new value for attribute.

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


/*
  Document-method: Ogre::Particle.new

  call-seq:
    Particle.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Particle *)new Ogre::Particle();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Particle.set_dimensions

  call-seq:
    set_dimensions(Real width, Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Particle_set_dimensions(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);
  {
    try {
      (arg1)->setDimensions(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Particle.has_own_dimensions

  call-seq:
    has_own_dimensions -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Particle_has_own_dimensions(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);
  {
    try {
      result = (bool)((Ogre::Particle const *)arg1)->hasOwnDimensions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Particle.get_own_width

  call-seq:
    get_own_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Particle_get_own_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Particle const *)arg1)->getOwnWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Particle.get_own_height

  call-seq:
    get_own_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Particle_get_own_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Particle const *)arg1)->getOwnHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Particle.set_rotation

  call-seq:
    set_rotation(Radian rad)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Particle_set_rotation(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);
  {
    try {
      (arg1)->setRotation((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Particle.get_rotation

  call-seq:
    get_rotation -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_Particle_get_rotation(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);
  {
    try {
      result = (Ogre::Radian *) &((Ogre::Particle const *)arg1)->getRotation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Particle._notify_owner

  call-seq:
    _notify_owner(ParticleSystem owner)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Particle__notify_owner(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);
  {
    try {
      (arg1)->_notifyOwner(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Particle._notify_visual_data

  call-seq:
    _notify_visual_data(ParticleVisualData vis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Particle__notify_visual_data(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);
  {
    try {
      (arg1)->_notifyVisualData(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Particle.get_visual_data

  call-seq:
    get_visual_data -> ParticleVisualData

An instance method.

*/
SWIGINTERN VALUE
_wrap_Particle_get_visual_data(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);
  {
    try {
      result = (Ogre::ParticleVisualData *)((Ogre::Particle const *)arg1)->getVisualData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleVisualData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Particle.reset_dimensions

  call-seq:
    reset_dimensions

An instance method.

*/
SWIGINTERN VALUE
_wrap_Particle_reset_dimensions(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);
  {
    try {
      (arg1)->resetDimensions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Particle(Ogre::Particle *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ParticleAffector < Ogre::Ogre::StringInterface

  Proxy of C++ Ogre::ParticleAffector class


*/
swig_class SwigClassParticleAffector;

SWIGINTERN void
free_Ogre_ParticleAffector(Ogre::ParticleAffector *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ParticleAffector._init_particle

  call-seq:
    _init_particle(Particle pParticle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleAffector__init_particle(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);
  {
    try {
      (arg1)->_initParticle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleAffector._affect_particles

  call-seq:
    _affect_particles(ParticleSystem pSystem, Real timeElapsed)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleAffector__affect_particles(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);
  {
    try {
      (arg1)->_affectParticles(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleAffector.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleAffector_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ParticleAffector const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ParticleAffectorFactory

  Proxy of C++ Ogre::ParticleAffectorFactory class


*/
swig_class SwigClassParticleAffectorFactory;

SWIGINTERN void
free_Ogre_ParticleAffectorFactory(Ogre::ParticleAffectorFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ParticleAffectorFactory.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleAffectorFactory_get_name(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);
  {
    try {
      result = ((Ogre::ParticleAffectorFactory const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleAffectorFactory.create_affector

  call-seq:
    create_affector(ParticleSystem psys) -> ParticleAffector

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleAffectorFactory_create_affector(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);
  {
    try {
      result = (Ogre::ParticleAffector *)(arg1)->createAffector(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleAffector, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleAffectorFactory.destroy_affector

  call-seq:
    destroy_affector(ParticleAffector e)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleAffectorFactory_destroy_affector(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);
  {
    try {
      (arg1)->destroyAffector(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::CmdAngle < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdAngle class


*/
swig_class SwigClassCmdAngle;


/*
  Document-method: Ogre::CmdAngle.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdAngle_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdAngle const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdAngle.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdAngle_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdAngle.new

  call-seq:
    CmdAngle.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdAngle *)new Ogre::EmitterCommands::CmdAngle();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdAngle(Ogre::EmitterCommands::CmdAngle *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdColour < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdColour class


*/
swig_class SwigClassCmdColour;


/*
  Document-method: Ogre::CmdColour.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdColour_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdColour const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdColour.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdColour_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdColour.new

  call-seq:
    CmdColour.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdColour *)new Ogre::EmitterCommands::CmdColour();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdColour(Ogre::EmitterCommands::CmdColour *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdColourRangeStart < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdColourRangeStart class


*/
swig_class SwigClassCmdColourRangeStart;


/*
  Document-method: Ogre::CmdColourRangeStart.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdColourRangeStart_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdColourRangeStart const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdColourRangeStart.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdColourRangeStart_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdColourRangeStart.new

  call-seq:
    CmdColourRangeStart.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdColourRangeStart *)new Ogre::EmitterCommands::CmdColourRangeStart();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdColourRangeStart(Ogre::EmitterCommands::CmdColourRangeStart *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdColourRangeEnd < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdColourRangeEnd class


*/
swig_class SwigClassCmdColourRangeEnd;


/*
  Document-method: Ogre::CmdColourRangeEnd.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdColourRangeEnd_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdColourRangeEnd const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdColourRangeEnd.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdColourRangeEnd_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdColourRangeEnd.new

  call-seq:
    CmdColourRangeEnd.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdColourRangeEnd *)new Ogre::EmitterCommands::CmdColourRangeEnd();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdColourRangeEnd(Ogre::EmitterCommands::CmdColourRangeEnd *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdDirection < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdDirection class


*/
swig_class SwigClassCmdDirection;


/*
  Document-method: Ogre::CmdDirection.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdDirection_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdDirection const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdDirection.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdDirection_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdDirection.new

  call-seq:
    CmdDirection.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdDirection *)new Ogre::EmitterCommands::CmdDirection();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdDirection(Ogre::EmitterCommands::CmdDirection *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdUp < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdUp class


*/
swig_class SwigClassCmdUp;


/*
  Document-method: Ogre::CmdUp.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdUp_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdUp const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdUp.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdUp_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdUp.new

  call-seq:
    CmdUp.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdUp *)new Ogre::EmitterCommands::CmdUp();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdUp(Ogre::EmitterCommands::CmdUp *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdEmissionRate < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdEmissionRate class


*/
swig_class SwigClassCmdEmissionRate;


/*
  Document-method: Ogre::CmdEmissionRate.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdEmissionRate_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdEmissionRate const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdEmissionRate.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdEmissionRate_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdEmissionRate.new

  call-seq:
    CmdEmissionRate.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdEmissionRate *)new Ogre::EmitterCommands::CmdEmissionRate();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdEmissionRate(Ogre::EmitterCommands::CmdEmissionRate *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdVelocity < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdVelocity class


*/
swig_class SwigClassCmdVelocity;


/*
  Document-method: Ogre::CmdVelocity.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdVelocity_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdVelocity const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdVelocity.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdVelocity_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdVelocity.new

  call-seq:
    CmdVelocity.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdVelocity *)new Ogre::EmitterCommands::CmdVelocity();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdVelocity(Ogre::EmitterCommands::CmdVelocity *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdMinVelocity < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdMinVelocity class


*/
swig_class SwigClassCmdMinVelocity;


/*
  Document-method: Ogre::CmdMinVelocity.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMinVelocity_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdMinVelocity const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdMinVelocity.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMinVelocity_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdMinVelocity.new

  call-seq:
    CmdMinVelocity.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdMinVelocity *)new Ogre::EmitterCommands::CmdMinVelocity();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMinVelocity(Ogre::EmitterCommands::CmdMinVelocity *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdMaxVelocity < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdMaxVelocity class


*/
swig_class SwigClassCmdMaxVelocity;


/*
  Document-method: Ogre::CmdMaxVelocity.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMaxVelocity_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdMaxVelocity const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdMaxVelocity.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMaxVelocity_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdMaxVelocity.new

  call-seq:
    CmdMaxVelocity.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdMaxVelocity *)new Ogre::EmitterCommands::CmdMaxVelocity();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMaxVelocity(Ogre::EmitterCommands::CmdMaxVelocity *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdTTL < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdTTL class


*/
swig_class SwigClassCmdTTL;


/*
  Document-method: Ogre::CmdTTL.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdTTL_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdTTL const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdTTL.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdTTL_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdTTL.new

  call-seq:
    CmdTTL.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdTTL *)new Ogre::EmitterCommands::CmdTTL();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdTTL(Ogre::EmitterCommands::CmdTTL *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdMinTTL < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdMinTTL class


*/
swig_class SwigClassCmdMinTTL;


/*
  Document-method: Ogre::CmdMinTTL.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMinTTL_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdMinTTL const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdMinTTL.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMinTTL_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdMinTTL.new

  call-seq:
    CmdMinTTL.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdMinTTL *)new Ogre::EmitterCommands::CmdMinTTL();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMinTTL(Ogre::EmitterCommands::CmdMinTTL *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdMaxTTL < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdMaxTTL class


*/
swig_class SwigClassCmdMaxTTL;


/*
  Document-method: Ogre::CmdMaxTTL.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMaxTTL_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdMaxTTL const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdMaxTTL.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMaxTTL_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdMaxTTL.new

  call-seq:
    CmdMaxTTL.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdMaxTTL *)new Ogre::EmitterCommands::CmdMaxTTL();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMaxTTL(Ogre::EmitterCommands::CmdMaxTTL *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdPosition < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdPosition class


*/
swig_class SwigClassCmdPosition;


/*
  Document-method: Ogre::CmdPosition.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdPosition_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdPosition const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdPosition.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdPosition_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdPosition.new

  call-seq:
    CmdPosition.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdPosition *)new Ogre::EmitterCommands::CmdPosition();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdPosition(Ogre::EmitterCommands::CmdPosition *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdDuration < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdDuration class


*/
swig_class SwigClassCmdDuration;


/*
  Document-method: Ogre::CmdDuration.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdDuration_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdDuration const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdDuration.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdDuration_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdDuration.new

  call-seq:
    CmdDuration.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdDuration *)new Ogre::EmitterCommands::CmdDuration();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdDuration(Ogre::EmitterCommands::CmdDuration *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdMinDuration < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdMinDuration class


*/
swig_class SwigClassCmdMinDuration;


/*
  Document-method: Ogre::CmdMinDuration.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMinDuration_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdMinDuration const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdMinDuration.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMinDuration_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdMinDuration.new

  call-seq:
    CmdMinDuration.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdMinDuration *)new Ogre::EmitterCommands::CmdMinDuration();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMinDuration(Ogre::EmitterCommands::CmdMinDuration *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdMaxDuration < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdMaxDuration class


*/
swig_class SwigClassCmdMaxDuration;


/*
  Document-method: Ogre::CmdMaxDuration.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMaxDuration_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdMaxDuration const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdMaxDuration.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMaxDuration_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdMaxDuration.new

  call-seq:
    CmdMaxDuration.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdMaxDuration *)new Ogre::EmitterCommands::CmdMaxDuration();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMaxDuration(Ogre::EmitterCommands::CmdMaxDuration *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdRepeatDelay < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdRepeatDelay class


*/
swig_class SwigClassCmdRepeatDelay;


/*
  Document-method: Ogre::CmdRepeatDelay.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdRepeatDelay_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdRepeatDelay const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdRepeatDelay.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdRepeatDelay_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdRepeatDelay.new

  call-seq:
    CmdRepeatDelay.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdRepeatDelay *)new Ogre::EmitterCommands::CmdRepeatDelay();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdRepeatDelay(Ogre::EmitterCommands::CmdRepeatDelay *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdMinRepeatDelay < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdMinRepeatDelay class


*/
swig_class SwigClassCmdMinRepeatDelay;


/*
  Document-method: Ogre::CmdMinRepeatDelay.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMinRepeatDelay_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdMinRepeatDelay const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdMinRepeatDelay.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMinRepeatDelay_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdMinRepeatDelay.new

  call-seq:
    CmdMinRepeatDelay.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdMinRepeatDelay *)new Ogre::EmitterCommands::CmdMinRepeatDelay();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMinRepeatDelay(Ogre::EmitterCommands::CmdMinRepeatDelay *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdMaxRepeatDelay < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdMaxRepeatDelay class


*/
swig_class SwigClassCmdMaxRepeatDelay;


/*
  Document-method: Ogre::CmdMaxRepeatDelay.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMaxRepeatDelay_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdMaxRepeatDelay const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdMaxRepeatDelay.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdMaxRepeatDelay_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdMaxRepeatDelay.new

  call-seq:
    CmdMaxRepeatDelay.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdMaxRepeatDelay *)new Ogre::EmitterCommands::CmdMaxRepeatDelay();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMaxRepeatDelay(Ogre::EmitterCommands::CmdMaxRepeatDelay *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdName < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdName class


*/
swig_class SwigClassCmdName;


/*
  Document-method: Ogre::CmdName.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdName_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdName const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdName.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdName_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdName.new

  call-seq:
    CmdName.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdName *)new Ogre::EmitterCommands::CmdName();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdName(Ogre::EmitterCommands::CmdName *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CmdEmittedEmitter < Ogre::Ogre::ParamCommand

  Proxy of C++ Ogre::CmdEmittedEmitter class


*/
swig_class SwigClassCmdEmittedEmitter;


/*
  Document-method: Ogre::CmdEmittedEmitter.do_get

  call-seq:
    do_get(void target) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdEmittedEmitter_do_get(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] )); 
  }
  {
    try {
      result = ((Ogre::EmitterCommands::CmdEmittedEmitter const *)arg1)->doGet((void const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CmdEmittedEmitter.do_set

  call-seq:
    do_set(void target, String val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_CmdEmittedEmitter_do_set(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;
  }
  {
    try {
      (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  


/*
  Document-method: Ogre::CmdEmittedEmitter.new

  call-seq:
    CmdEmittedEmitter.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmitterCommands::CmdEmittedEmitter *)new Ogre::EmitterCommands::CmdEmittedEmitter();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdEmittedEmitter(Ogre::EmitterCommands::CmdEmittedEmitter *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ParticleEmitter < Ogre::Ogre::StringInterface, Ogre::Ogre::Particle

  Proxy of C++ Ogre::ParticleEmitter class


*/
swig_class SwigClassParticleEmitter;

SWIGINTERN void
free_Ogre_ParticleEmitter(Ogre::ParticleEmitter *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ParticleEmitter.set_position

  call-seq:
    set_position(Vector3 pos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_position(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);
  {
    try {
      (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_position

  call-seq:
    get_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_position(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::ParticleEmitter const *)arg1)->getPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_direction

  call-seq:
    set_direction(Vector3 direction)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_direction(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);
  {
    try {
      (arg1)->setDirection((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_direction

  call-seq:
    get_direction -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_direction(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::ParticleEmitter const *)arg1)->getDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_up

  call-seq:
    set_up(Vector3 up)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_up(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);
  {
    try {
      (arg1)->setUp((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_up

  call-seq:
    get_up -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_up(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::ParticleEmitter const *)arg1)->getUp();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_angle

  call-seq:
    set_angle(Radian angle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_angle(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);
  {
    try {
      (arg1)->setAngle((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_angle

  call-seq:
    get_angle -> Radian

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_angle(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);
  {
    try {
      result = (Ogre::Radian *) &((Ogre::ParticleEmitter const *)arg1)->getAngle();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_particle_velocity

  call-seq:
    set_particle_velocity(Real speed)
    set_particle_velocity(Real min, Real max)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_particle_velocity__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);
  {
    try {
      (arg1)->setParticleVelocity(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_set_particle_velocity__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);
  {
    try {
      (arg1)->setParticleVelocity(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleEmitter_set_particle_velocity(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_set_particle_velocity__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_set_particle_velocity__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleEmitter.set_particle_velocity", 
    "    void ParticleEmitter.set_particle_velocity(Ogre::Real speed)\n"
    "    void ParticleEmitter.set_particle_velocity(Ogre::Real min, Ogre::Real max)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_min_particle_velocity

  call-seq:
    set_min_particle_velocity(Real min)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_min_particle_velocity(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);
  {
    try {
      (arg1)->setMinParticleVelocity(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_max_particle_velocity

  call-seq:
    set_max_particle_velocity(Real max)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_max_particle_velocity(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);
  {
    try {
      (arg1)->setMaxParticleVelocity(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_particle_velocity

  call-seq:
    get_particle_velocity -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_particle_velocity(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getParticleVelocity();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_min_particle_velocity

  call-seq:
    get_min_particle_velocity -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_min_particle_velocity(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMinParticleVelocity();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_max_particle_velocity

  call-seq:
    get_max_particle_velocity -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_max_particle_velocity(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMaxParticleVelocity();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_emission_rate

  call-seq:
    set_emission_rate(Real particlesPerSecond)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_emission_rate(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);
  {
    try {
      (arg1)->setEmissionRate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_emission_rate

  call-seq:
    get_emission_rate -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_emission_rate(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getEmissionRate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_time_to_live

  call-seq:
    set_time_to_live(Real ttl)
    set_time_to_live(Real minTtl, Real maxTtl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_time_to_live__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);
  {
    try {
      (arg1)->setTimeToLive(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_set_time_to_live__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);
  {
    try {
      (arg1)->setTimeToLive(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleEmitter_set_time_to_live(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_set_time_to_live__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_set_time_to_live__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleEmitter.set_time_to_live", 
    "    void ParticleEmitter.set_time_to_live(Ogre::Real ttl)\n"
    "    void ParticleEmitter.set_time_to_live(Ogre::Real minTtl, Ogre::Real maxTtl)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_min_time_to_live

  call-seq:
    set_min_time_to_live(Real min)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_min_time_to_live(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);
  {
    try {
      (arg1)->setMinTimeToLive(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_max_time_to_live

  call-seq:
    set_max_time_to_live(Real max)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_max_time_to_live(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);
  {
    try {
      (arg1)->setMaxTimeToLive(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_time_to_live

  call-seq:
    get_time_to_live -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_time_to_live(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getTimeToLive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_min_time_to_live

  call-seq:
    get_min_time_to_live -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_min_time_to_live(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMinTimeToLive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_max_time_to_live

  call-seq:
    get_max_time_to_live -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_max_time_to_live(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMaxTimeToLive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_colour

  call-seq:
    set_colour(ColourValue colour)
    set_colour(ColourValue colourStart, ColourValue colourEnd)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_colour__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);
  {
    try {
      (arg1)->setColour((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_set_colour__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);
  {
    try {
      (arg1)->setColour((Ogre::ColourValue const &)*arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleEmitter_set_colour(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_set_colour__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_set_colour__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleEmitter.set_colour", 
    "    void ParticleEmitter.set_colour(Ogre::ColourValue const &colour)\n"
    "    void ParticleEmitter.set_colour(Ogre::ColourValue const &colourStart, Ogre::ColourValue const &colourEnd)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_colour_range_start

  call-seq:
    set_colour_range_start(ColourValue colour)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_colour_range_start(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);
  {
    try {
      (arg1)->setColourRangeStart((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_colour_range_end

  call-seq:
    set_colour_range_end(ColourValue colour)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_colour_range_end(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);
  {
    try {
      (arg1)->setColourRangeEnd((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_colour

  call-seq:
    get_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::ParticleEmitter const *)arg1)->getColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_colour_range_start

  call-seq:
    get_colour_range_start -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_colour_range_start(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::ParticleEmitter const *)arg1)->getColourRangeStart();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_colour_range_end

  call-seq:
    get_colour_range_end -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_colour_range_end(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::ParticleEmitter const *)arg1)->getColourRangeEnd();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter._get_emission_count

  call-seq:
    _get_emission_count(Real timeElapsed) -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter__get_emission_count(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);
  {
    try {
      result = (unsigned short)(arg1)->_getEmissionCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter._init_particle

  call-seq:
    _init_particle(Particle pParticle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter__init_particle(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);
  {
    try {
      (arg1)->_initParticle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ParticleEmitter const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_enabled

  call-seq:
    set_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_enabled(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);
  {
    try {
      (arg1)->setEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_enabled

  call-seq:
    get_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_enabled(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);
  {
    try {
      result = (bool)((Ogre::ParticleEmitter const *)arg1)->getEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_start_time

  call-seq:
    set_start_time(Real startTime)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_start_time(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);
  {
    try {
      (arg1)->setStartTime(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_start_time

  call-seq:
    get_start_time -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_start_time(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getStartTime();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_duration

  call-seq:
    set_duration(Real duration)
    set_duration(Real min, Real max)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_duration__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);
  {
    try {
      (arg1)->setDuration(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_duration

  call-seq:
    get_duration -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_duration(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getDuration();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_duration

  call-seq:
    set_duration(Real duration)
    set_duration(Real min, Real max)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_duration__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);
  {
    try {
      (arg1)->setDuration(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleEmitter_set_duration(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_set_duration__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_set_duration__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleEmitter.set_duration", 
    "    void ParticleEmitter.set_duration(Ogre::Real duration)\n"
    "    void ParticleEmitter.set_duration(Ogre::Real min, Ogre::Real max)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_min_duration

  call-seq:
    set_min_duration(Real min)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_min_duration(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);
  {
    try {
      (arg1)->setMinDuration(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_max_duration

  call-seq:
    set_max_duration(Real max)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_max_duration(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);
  {
    try {
      (arg1)->setMaxDuration(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_min_duration

  call-seq:
    get_min_duration -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_min_duration(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMinDuration();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_max_duration

  call-seq:
    get_max_duration -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_max_duration(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMaxDuration();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_repeat_delay

  call-seq:
    set_repeat_delay(Real duration)
    set_repeat_delay(Real min, Real max)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_repeat_delay__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);
  {
    try {
      (arg1)->setRepeatDelay(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_repeat_delay

  call-seq:
    get_repeat_delay -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_repeat_delay(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getRepeatDelay();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_repeat_delay

  call-seq:
    set_repeat_delay(Real duration)
    set_repeat_delay(Real min, Real max)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_repeat_delay__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);
  {
    try {
      (arg1)->setRepeatDelay(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleEmitter_set_repeat_delay(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_set_repeat_delay__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_set_repeat_delay__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleEmitter.set_repeat_delay", 
    "    void ParticleEmitter.set_repeat_delay(Ogre::Real duration)\n"
    "    void ParticleEmitter.set_repeat_delay(Ogre::Real min, Ogre::Real max)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_min_repeat_delay

  call-seq:
    set_min_repeat_delay(Real min)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_min_repeat_delay(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);
  {
    try {
      (arg1)->setMinRepeatDelay(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_max_repeat_delay

  call-seq:
    set_max_repeat_delay(Real max)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_max_repeat_delay(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);
  {
    try {
      (arg1)->setMaxRepeatDelay(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_min_repeat_delay

  call-seq:
    get_min_repeat_delay -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_min_repeat_delay(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMinRepeatDelay();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_max_repeat_delay

  call-seq:
    get_max_repeat_delay -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_max_repeat_delay(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMaxRepeatDelay();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ParticleEmitter const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_name

  call-seq:
    set_name(String newName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_name(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;
  }
  {
    try {
      (arg1)->setName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.get_emitted_emitter

  call-seq:
    get_emitted_emitter -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_get_emitted_emitter(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ParticleEmitter const *)arg1)->getEmittedEmitter();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_emitted_emitter

  call-seq:
    set_emitted_emitter(String emittedEmitter)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_emitted_emitter(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;
  }
  {
    try {
      (arg1)->setEmittedEmitter((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.is_emitted

  call-seq:
    is_emitted -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_is_emitted(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);
  {
    try {
      result = (bool)((Ogre::ParticleEmitter const *)arg1)->isEmitted();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitter.set_emitted

  call-seq:
    set_emitted(bool emitted)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitter_set_emitted(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);
  {
    try {
      (arg1)->setEmitted(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ParticleEmitterFactory

  Proxy of C++ Ogre::ParticleEmitterFactory class


*/
swig_class SwigClassParticleEmitterFactory;

SWIGINTERN void
free_Ogre_ParticleEmitterFactory(Ogre::ParticleEmitterFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ParticleEmitterFactory.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitterFactory_get_name(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);
  {
    try {
      result = ((Ogre::ParticleEmitterFactory const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitterFactory.create_emitter

  call-seq:
    create_emitter(ParticleSystem psys) -> ParticleEmitter

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitterFactory_create_emitter(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);
  {
    try {
      result = (Ogre::ParticleEmitter *)(arg1)->createEmitter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleEmitter, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitterFactory.destroy_emitter

  call-seq:
    destroy_emitter(ParticleEmitter e)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleEmitterFactory_destroy_emitter(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);
  {
    try {
      (arg1)->destroyEmitter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ParticleIterator

  Proxy of C++ Ogre::ParticleIterator class


*/
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);
  {
    try {
      result = (bool)(arg1)->end();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleIterator.get_next

  call-seq:
    get_next -> Particle

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleIterator_get_next(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);
  {
    try {
      result = (Ogre::Particle *)(arg1)->getNext();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Particle, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleIterator(Ogre::ParticleIterator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ConcreteNode

  Proxy of C++ Ogre::ConcreteNode class


*/
swig_class SwigClassConcreteNode;


/*
  Document-method: Ogre::ConcreteNode.token

  call-seq:
    token -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ConcreteNode.token=

  call-seq:
    token=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ConcreteNode.file

  call-seq:
    file -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ConcreteNode.file=

  call-seq:
    file=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ConcreteNode.line

  call-seq:
    line -> unsigned int

Get value of attribute.

*/

/*
  Document-method: Ogre::ConcreteNode.line=

  call-seq:
    line=(x) -> unsigned int

Set new value for attribute.

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



/*
  Document-method: Ogre::ConcreteNode.type

  call-seq:
    type -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::ConcreteNode.type=

  call-seq:
    type=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::ConcreteNode.children

  call-seq:
    children -> ConcreteNodeList

Get value of attribute.

*/

/*
  Document-method: Ogre::ConcreteNode.children=

  call-seq:
    children=(x) -> ConcreteNodeList

Set new value for attribute.

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



/*
  Document-method: Ogre::ConcreteNode.parent

  call-seq:
    parent -> ConcreteNode

Get value of attribute.

*/

/*
  Document-method: Ogre::ConcreteNode.parent=

  call-seq:
    parent=(x) -> ConcreteNode

Set new value for attribute.

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


/*
  Document-method: Ogre::ConcreteNode.new

  call-seq:
    ConcreteNode.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ConcreteNode *)new Ogre::ConcreteNode();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ConcreteNode(Ogre::ConcreteNode *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::AbstractNode

  Proxy of C++ Ogre::AbstractNode class


*/
swig_class SwigClassAbstractNode;


/*
  Document-method: Ogre::AbstractNode.file

  call-seq:
    file -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::AbstractNode.file=

  call-seq:
    file=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::AbstractNode.line

  call-seq:
    line -> unsigned int

Get value of attribute.

*/

/*
  Document-method: Ogre::AbstractNode.line=

  call-seq:
    line=(x) -> unsigned int

Set new value for attribute.

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



/*
  Document-method: Ogre::AbstractNode.type

  call-seq:
    type -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::AbstractNode.type=

  call-seq:
    type=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::AbstractNode.parent

  call-seq:
    parent -> AbstractNode

Get value of attribute.

*/

/*
  Document-method: Ogre::AbstractNode.parent=

  call-seq:
    parent=(x) -> AbstractNode

Set new value for attribute.

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



/*
  Document-method: Ogre::AbstractNode.context

  call-seq:
    context -> Any

Get value of attribute.

*/

/*
  Document-method: Ogre::AbstractNode.context=

  call-seq:
    context=(x) -> Any

Set new value for attribute.

*/
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);
  {
    try {
      result = (Ogre::AbstractNode *)((Ogre::AbstractNode const *)arg1)->clone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AbstractNode.get_value

  call-seq:
    get_value -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_AbstractNode_get_value(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);
  {
    try {
      result = ((Ogre::AbstractNode const *)arg1)->getValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::AtomAbstractNode < Ogre::Ogre::AbstractNode

  Proxy of C++ Ogre::AtomAbstractNode class


*/
swig_class SwigClassAtomAbstractNode;


/*
  Document-method: Ogre::AtomAbstractNode.value

  call-seq:
    value -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::AtomAbstractNode.value=

  call-seq:
    value=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::AtomAbstractNode.id

  call-seq:
    id -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::AtomAbstractNode.id=

  call-seq:
    id=(x) -> uint32

Set new value for attribute.

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


/*
  Document-method: Ogre::AtomAbstractNode.new

  call-seq:
    AtomAbstractNode.new(AbstractNode ptr)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::AtomAbstractNode *)new Ogre::AtomAbstractNode(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (Ogre::AbstractNode *)((Ogre::AtomAbstractNode const *)arg1)->clone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AtomAbstractNode.get_value

  call-seq:
    get_value -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_AtomAbstractNode_get_value(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);
  {
    try {
      result = ((Ogre::AtomAbstractNode const *)arg1)->getValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AtomAbstractNode(Ogre::AtomAbstractNode *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ObjectAbstractNode < Ogre::Ogre::AbstractNode

  Proxy of C++ Ogre::ObjectAbstractNode class


*/
swig_class SwigClassObjectAbstractNode;


/*
  Document-method: Ogre::ObjectAbstractNode.name

  call-seq:
    name -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ObjectAbstractNode.name=

  call-seq:
    name=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ObjectAbstractNode.cls

  call-seq:
    cls -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ObjectAbstractNode.cls=

  call-seq:
    cls=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ObjectAbstractNode.bases

  call-seq:
    bases -> std::vector<(Ogre::String,std::allocator<(Ogre::String)>)>

Get value of attribute.

*/

/*
  Document-method: Ogre::ObjectAbstractNode.bases=

  call-seq:
    bases=(x) -> std::vector<(Ogre::String,std::allocator<(Ogre::String)>)>

Set new value for attribute.

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



/*
  Document-method: Ogre::ObjectAbstractNode.id

  call-seq:
    id -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::ObjectAbstractNode.id=

  call-seq:
    id=(x) -> uint32

Set new value for attribute.

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



/*
  Document-method: Ogre::ObjectAbstractNode.abstract

  call-seq:
    abstract -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::ObjectAbstractNode.abstract=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::ObjectAbstractNode.children

  call-seq:
    children -> AbstractNodeList

Get value of attribute.

*/

/*
  Document-method: Ogre::ObjectAbstractNode.children=

  call-seq:
    children=(x) -> AbstractNodeList

Set new value for attribute.

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



/*
  Document-method: Ogre::ObjectAbstractNode.overrides

  call-seq:
    overrides -> AbstractNodeList

Get value of attribute.

*/

/*
  Document-method: Ogre::ObjectAbstractNode.overrides=

  call-seq:
    overrides=(x) -> AbstractNodeList

Set new value for attribute.

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


/*
  Document-method: Ogre::ObjectAbstractNode.new

  call-seq:
    ObjectAbstractNode.new(AbstractNode ptr)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::ObjectAbstractNode *)new Ogre::ObjectAbstractNode(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (Ogre::AbstractNode *)((Ogre::ObjectAbstractNode const *)arg1)->clone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ObjectAbstractNode.get_value

  call-seq:
    get_value -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ObjectAbstractNode_get_value(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);
  {
    try {
      result = ((Ogre::ObjectAbstractNode const *)arg1)->getValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ObjectAbstractNode.add_variable

  call-seq:
    add_variable(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ObjectAbstractNode_add_variable(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;
  }
  {
    try {
      (arg1)->addVariable((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ObjectAbstractNode.set_variable

  call-seq:
    set_variable(String name, String value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ObjectAbstractNode_set_variable(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;
  }
  {
    try {
      (arg1)->setVariable((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::ObjectAbstractNode.get_variable

  call-seq:
    get_variable(String name) -> std::pair<(bool,Ogre::String)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_ObjectAbstractNode_get_variable(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;
  }
  {
    try {
      result = ((Ogre::ObjectAbstractNode const *)arg1)->getVariable((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
}



/*
  Document-method: Ogre::ObjectAbstractNode.get_variables

  call-seq:
    get_variables -> Ogre::map<(Ogre::String,Ogre::String,std::less<(Ogre::String)>,Ogre::STLAllocator<(std::pair<(q(const).Ogre::String,Ogre::String)>,Ogre::GeneralAllocPolicy)>)>::type

An instance method.

*/
SWIGINTERN VALUE
_wrap_ObjectAbstractNode_get_variables(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);
  {
    try {
      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();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}


/*
  Document-class: Ogre::PropertyAbstractNode < Ogre::Ogre::AbstractNode

  Proxy of C++ Ogre::PropertyAbstractNode class


*/
swig_class SwigClassPropertyAbstractNode;


/*
  Document-method: Ogre::PropertyAbstractNode.name

  call-seq:
    name -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::PropertyAbstractNode.name=

  call-seq:
    name=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::PropertyAbstractNode.id

  call-seq:
    id -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::PropertyAbstractNode.id=

  call-seq:
    id=(x) -> uint32

Set new value for attribute.

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


/*
  Document-method: Ogre::PropertyAbstractNode.new

  call-seq:
    PropertyAbstractNode.new(AbstractNode ptr)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::PropertyAbstractNode *)new Ogre::PropertyAbstractNode(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (Ogre::AbstractNode *)((Ogre::PropertyAbstractNode const *)arg1)->clone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PropertyAbstractNode.get_value

  call-seq:
    get_value -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PropertyAbstractNode_get_value(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);
  {
    try {
      result = ((Ogre::PropertyAbstractNode const *)arg1)->getValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PropertyAbstractNode(Ogre::PropertyAbstractNode *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ImportAbstractNode < Ogre::Ogre::AbstractNode

  Proxy of C++ Ogre::ImportAbstractNode class


*/
swig_class SwigClassImportAbstractNode;


/*
  Document-method: Ogre::ImportAbstractNode.target

  call-seq:
    target -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ImportAbstractNode.target=

  call-seq:
    target=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ImportAbstractNode.source

  call-seq:
    source -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ImportAbstractNode.source=

  call-seq:
    source=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::ImportAbstractNode.new

  call-seq:
    ImportAbstractNode.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ImportAbstractNode *)new Ogre::ImportAbstractNode();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (Ogre::AbstractNode *)((Ogre::ImportAbstractNode const *)arg1)->clone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ImportAbstractNode.get_value

  call-seq:
    get_value -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ImportAbstractNode_get_value(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);
  {
    try {
      result = ((Ogre::ImportAbstractNode const *)arg1)->getValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ImportAbstractNode(Ogre::ImportAbstractNode *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::VariableAccessAbstractNode < Ogre::Ogre::AbstractNode

  Proxy of C++ Ogre::VariableAccessAbstractNode class


*/
swig_class SwigClassVariableAccessAbstractNode;


/*
  Document-method: Ogre::VariableAccessAbstractNode.name

  call-seq:
    name -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::VariableAccessAbstractNode.name=

  call-seq:
    name=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::VariableAccessAbstractNode.new

  call-seq:
    VariableAccessAbstractNode.new(AbstractNode ptr)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::VariableAccessAbstractNode *)new Ogre::VariableAccessAbstractNode(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (Ogre::AbstractNode *)((Ogre::VariableAccessAbstractNode const *)arg1)->clone();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VariableAccessAbstractNode.get_value

  call-seq:
    get_value -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_VariableAccessAbstractNode_get_value(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);
  {
    try {
      result = ((Ogre::VariableAccessAbstractNode const *)arg1)->getValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VariableAccessAbstractNode(Ogre::VariableAccessAbstractNode *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ScriptCompiler

  Proxy of C++ Ogre::ScriptCompiler class


*/
swig_class SwigClassScriptCompiler;


/*
  Document-method: Ogre.CE_STRINGEXPECTED

  call-seq:
    CE_STRINGEXPECTED -> int

A class method.

*/

/*
  Document-method: Ogre.CE_NUMBEREXPECTED

  call-seq:
    CE_NUMBEREXPECTED -> int

A class method.

*/

/*
  Document-method: Ogre.CE_FEWERPARAMETERSEXPECTED

  call-seq:
    CE_FEWERPARAMETERSEXPECTED -> int

A class method.

*/

/*
  Document-method: Ogre.CE_VARIABLEEXPECTED

  call-seq:
    CE_VARIABLEEXPECTED -> int

A class method.

*/

/*
  Document-method: Ogre.CE_UNDEFINEDVARIABLE

  call-seq:
    CE_UNDEFINEDVARIABLE -> int

A class method.

*/

/*
  Document-method: Ogre.CE_OBJECTNAMEEXPECTED

  call-seq:
    CE_OBJECTNAMEEXPECTED -> int

A class method.

*/

/*
  Document-method: Ogre.CE_OBJECTALLOCATIONERROR

  call-seq:
    CE_OBJECTALLOCATIONERROR -> int

A class method.

*/

/*
  Document-method: Ogre.CE_INVALIDPARAMETERS

  call-seq:
    CE_INVALIDPARAMETERS -> int

A class method.

*/

/*
  Document-method: Ogre.CE_DUPLICATEOVERRIDE

  call-seq:
    CE_DUPLICATEOVERRIDE -> int

A class method.

*/

/*
  Document-method: Ogre.CE_UNEXPECTEDTOKEN

  call-seq:
    CE_UNEXPECTEDTOKEN -> int

A class method.

*/

/*
  Document-method: Ogre.CE_OBJECTBASENOTFOUND

  call-seq:
    CE_OBJECTBASENOTFOUND -> int

A class method.

*/

/*
  Document-method: Ogre.CE_UNSUPPORTEDBYRENDERSYSTEM

  call-seq:
    CE_UNSUPPORTEDBYRENDERSYSTEM -> int

A class method.

*/

/*
  Document-method: Ogre.CE_REFERENCETOANONEXISTINGOBJECT

  call-seq:
    CE_REFERENCETOANONEXISTINGOBJECT -> int

A class method.

*/

/*
  Document-method: Ogre::ScriptCompiler.format_error_code

  call-seq:
    format_error_code(uint32 code) -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompiler_format_error_code(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);
  {
    try {
      result = Ogre::ScriptCompiler::formatErrorCode(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  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;
  }
  


/*
  Document-method: Ogre::ScriptCompiler.new

  call-seq:
    ScriptCompiler.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ScriptCompiler *)new Ogre::ScriptCompiler();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptCompiler(Ogre::ScriptCompiler *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ScriptCompiler.compile

  call-seq:
    compile(String str, String source, String group) -> bool
    compile(ConcreteNodeListPtr nodes, String group) -> bool

An instance method.

*/
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;
  }
  {
    try {
      result = (bool)(arg1)->compile((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
  }
  {
    try {
      result = (bool)(arg1)->compile((Ogre::ConcreteNodeListPtr const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::ScriptCompiler._generate_ast

  call-seq:
    _generate_ast(String str, String source, bool doImports=false, bool doObjects=false, 
    bool doVariables=false) -> AbstractNodeListPtr
    _generate_ast(String str, String source, bool doImports=false, bool doObjects=false) -> AbstractNodeListPtr
    _generate_ast(String str, String source, bool doImports=false) -> AbstractNodeListPtr
    _generate_ast(String str, String source) -> AbstractNodeListPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompiler__generate_ast__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);
  {
    try {
      result = (arg1)->_generateAST((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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__generate_ast__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);
  {
    try {
      result = (arg1)->_generateAST((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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__generate_ast__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);
  {
    try {
      result = (arg1)->_generateAST((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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__generate_ast__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;
  }
  {
    try {
      result = (arg1)->_generateAST((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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__generate_ast(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__generate_ast__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__generate_ast__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__generate_ast__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__generate_ast__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "ScriptCompiler._generate_ast", 
    "    Ogre::AbstractNodeListPtr ScriptCompiler._generate_ast(Ogre::String const &str, Ogre::String const &source, bool doImports, bool doObjects, bool doVariables)\n"
    "    Ogre::AbstractNodeListPtr ScriptCompiler._generate_ast(Ogre::String const &str, Ogre::String const &source, bool doImports, bool doObjects)\n"
    "    Ogre::AbstractNodeListPtr ScriptCompiler._generate_ast(Ogre::String const &str, Ogre::String const &source, bool doImports)\n"
    "    Ogre::AbstractNodeListPtr ScriptCompiler._generate_ast(Ogre::String const &str, Ogre::String const &source)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompiler._compile

  call-seq:
    _compile(AbstractNodeListPtr nodes, String group, bool doImports=true, 
    bool doObjects=true, bool doVariables=true) -> bool
    _compile(AbstractNodeListPtr nodes, String group, bool doImports=true, 
    bool doObjects=true) -> bool
    _compile(AbstractNodeListPtr nodes, String group, bool doImports=true) -> bool
    _compile(AbstractNodeListPtr nodes, String group) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)(arg1)->_compile(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  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);
  {
    try {
      result = (bool)(arg1)->_compile(arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = (bool)(arg1)->_compile(arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
  }
  {
    try {
      result = (bool)(arg1)->_compile(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::ScriptCompiler.add_error

  call-seq:
    add_error(uint32 code, String file, int line, String msg="")
    add_error(uint32 code, String file, int line)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompiler_add_error__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;
  }
  {
    try {
      (arg1)->addError(arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_add_error__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);
  {
    try {
      (arg1)->addError(arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ScriptCompiler_add_error(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_add_error__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_add_error__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ScriptCompiler.add_error", 
    "    void ScriptCompiler.add_error(Ogre::uint32 code, Ogre::String const &file, int line, Ogre::String const &msg)\n"
    "    void ScriptCompiler.add_error(Ogre::uint32 code, Ogre::String const &file, int line)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompiler.set_listener

  call-seq:
    set_listener(ScriptCompilerListener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompiler_set_listener(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);
  {
    try {
      (arg1)->setListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompiler.get_listener

  call-seq:
    get_listener -> ScriptCompilerListener

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompiler_get_listener(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);
  {
    try {
      result = (Ogre::ScriptCompilerListener *)(arg1)->getListener();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptCompilerListener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompiler.get_resource_group

  call-seq:
    get_resource_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompiler_get_resource_group(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ScriptCompiler const *)arg1)->getResourceGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompiler._fire_event

  call-seq:
    _fire_event(ScriptCompilerEvent evt, void retval) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompiler__fire_event(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] )); 
  }
  {
    try {
      result = (bool)(arg1)->_fireEvent(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre.ID_ON

  call-seq:
    ID_ON -> int

A class method.

*/

/*
  Document-method: Ogre.ID_OFF

  call-seq:
    ID_OFF -> int

A class method.

*/

/*
  Document-method: Ogre.ID_TRUE

  call-seq:
    ID_TRUE -> int

A class method.

*/

/*
  Document-method: Ogre.ID_FALSE

  call-seq:
    ID_FALSE -> int

A class method.

*/

/*
  Document-method: Ogre.ID_YES

  call-seq:
    ID_YES -> int

A class method.

*/

/*
  Document-method: Ogre.ID_NO

  call-seq:
    ID_NO -> int

A class method.

*/

/*
  Document-class: Ogre::ScriptCompilerEvent

  Proxy of C++ Ogre::ScriptCompilerEvent class


*/
swig_class SwigClassScriptCompilerEvent;


/*
  Document-method: Ogre::ScriptCompilerEvent.mType

  call-seq:
    mType -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ScriptCompilerEvent.mType=

  call-seq:
    mType=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::ScriptCompilerEvent.new

  call-seq:
    ScriptCompilerEvent.new(String type)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ScriptCompilerEvent *)new Ogre::ScriptCompilerEvent((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::ScriptCompilerListener

  Proxy of C++ Ogre::ScriptCompilerListener class


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


/*
  Document-method: Ogre::ScriptCompilerListener.new

  call-seq:
    ScriptCompilerListener.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ScriptCompilerListener *)new Ogre::ScriptCompilerListener();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptCompilerListener(Ogre::ScriptCompilerListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ScriptCompilerListener.import_file

  call-seq:
    import_file(ScriptCompiler compiler, String name) -> ConcreteNodeListPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerListener_import_file(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;
  }
  {
    try {
      result = (arg1)->importFile(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ScriptCompilerListener.pre_conversion

  call-seq:
    pre_conversion(ScriptCompiler compiler, ConcreteNodeListPtr nodes)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerListener_pre_conversion(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));
    }
  }
  {
    try {
      (arg1)->preConversion(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerListener.post_conversion

  call-seq:
    post_conversion(ScriptCompiler compiler, AbstractNodeListPtr ?) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerListener_post_conversion(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);
  {
    try {
      result = (bool)(arg1)->postConversion(arg2,(Ogre::AbstractNodeListPtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerListener.handle_error

  call-seq:
    handle_error(ScriptCompiler compiler, uint32 code, String file, 
    int line, String msg)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerListener_handle_error(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;
  }
  {
    try {
      (arg1)->handleError(arg2,arg3,(Ogre::String const &)*arg4,arg5,(Ogre::String const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::ScriptCompilerListener.handle_event

  call-seq:
    handle_event(ScriptCompiler compiler, ScriptCompilerEvent evt, void retval) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerListener_handle_event(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] )); 
  }
  {
    try {
      result = (bool)(arg1)->handleEvent(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ScriptCompilerManager < Ogre::Ogre::ScriptLoader

  Proxy of C++ Ogre::ScriptCompilerManager class


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


/*
  Document-method: Ogre::ScriptCompilerManager.new

  call-seq:
    ScriptCompilerManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ScriptCompilerManager *)new Ogre::ScriptCompilerManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptCompilerManager(Ogre::ScriptCompilerManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ScriptCompilerManager.set_listener

  call-seq:
    set_listener(ScriptCompilerListener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerManager_set_listener(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);
  {
    try {
      (arg1)->setListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerManager.get_listener

  call-seq:
    get_listener -> ScriptCompilerListener

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerManager_get_listener(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);
  {
    try {
      result = (Ogre::ScriptCompilerListener *)(arg1)->getListener();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptCompilerListener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerManager.add_translator_manager

  call-seq:
    add_translator_manager(ScriptTranslatorManager man)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerManager_add_translator_manager(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);
  {
    try {
      (arg1)->addTranslatorManager(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerManager.remove_translator_manager

  call-seq:
    remove_translator_manager(ScriptTranslatorManager man)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerManager_remove_translator_manager(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);
  {
    try {
      (arg1)->removeTranslatorManager(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerManager.clear_translator_managers

  call-seq:
    clear_translator_managers

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerManager_clear_translator_managers(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);
  {
    try {
      (arg1)->clearTranslatorManagers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerManager.get_translator

  call-seq:
    get_translator(AbstractNodePtr node) -> ScriptTranslator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerManager_get_translator(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);
  {
    try {
      result = (Ogre::ScriptTranslator *)(arg1)->getTranslator((Ogre::AbstractNodePtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptTranslator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerManager.add_script_pattern

  call-seq:
    add_script_pattern(String pattern)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerManager_add_script_pattern(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;
  }
  {
    try {
      (arg1)->addScriptPattern((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerManager.get_script_patterns

  call-seq:
    get_script_patterns -> StringVector

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerManager_get_script_patterns(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);
  {
    try {
      result = (Ogre::StringVector *) &((Ogre::ScriptCompilerManager const *)arg1)->getScriptPatterns();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerManager.parse_script

  call-seq:
    parse_script(DataStreamPtr stream, String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerManager_parse_script(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;
  }
  {
    try {
      (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerManager.get_loading_order

  call-seq:
    get_loading_order -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerManager_get_loading_order(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ScriptCompilerManager const *)arg1)->getLoadingOrder();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerManager.get_singleton

  call-seq:
    get_singleton -> ScriptCompilerManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::ScriptCompilerManager *) &Ogre::ScriptCompilerManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptCompilerManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptCompilerManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> ScriptCompilerManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ScriptCompilerManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::ScriptCompilerManager *)Ogre::ScriptCompilerManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptCompilerManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PreApplyTextureAliasesScriptCompilerEvent < Ogre::Ogre::ScriptCompilerEvent

  Proxy of C++ Ogre::PreApplyTextureAliasesScriptCompilerEvent class


*/
swig_class SwigClassPreApplyTextureAliasesScriptCompilerEvent;


/*
  Document-method: Ogre::PreApplyTextureAliasesScriptCompilerEvent.mMaterial

  call-seq:
    mMaterial -> Material

Get value of attribute.

*/

/*
  Document-method: Ogre::PreApplyTextureAliasesScriptCompilerEvent.mMaterial=

  call-seq:
    mMaterial=(x) -> Material

Set new value for attribute.

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



/*
  Document-method: Ogre::PreApplyTextureAliasesScriptCompilerEvent.mAliases

  call-seq:
    mAliases -> AliasTextureNamePairList

Get value of attribute.

*/

/*
  Document-method: Ogre::PreApplyTextureAliasesScriptCompilerEvent.mAliases=

  call-seq:
    mAliases=(x) -> AliasTextureNamePairList

Set new value for attribute.

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



/*
  Document-method: Ogre::PreApplyTextureAliasesScriptCompilerEvent.eventType

  call-seq:
    eventType -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::PreApplyTextureAliasesScriptCompilerEvent.eventType=

  call-seq:
    eventType=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::PreApplyTextureAliasesScriptCompilerEvent.PreApplyTextureAliasesScriptCompilerEvent_eventType

  call-seq:
    PreApplyTextureAliasesScriptCompilerEvent_eventType -> String

Get value of attribute.

*/
SWIGINTERN VALUE
_wrap_PreApplyTextureAliasesScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::PreApplyTextureAliasesScriptCompilerEvent::eventType));
  return _val;
}



/*
  Document-method: Ogre::PreApplyTextureAliasesScriptCompilerEvent.PreApplyTextureAliasesScriptCompilerEvent_eventType=

  call-seq:
    PreApplyTextureAliasesScriptCompilerEvent_eventType=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::PreApplyTextureAliasesScriptCompilerEvent.new

  call-seq:
    PreApplyTextureAliasesScriptCompilerEvent.new(Material material, AliasTextureNamePairList aliases)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::PreApplyTextureAliasesScriptCompilerEvent *)new Ogre::PreApplyTextureAliasesScriptCompilerEvent(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PreApplyTextureAliasesScriptCompilerEvent(Ogre::PreApplyTextureAliasesScriptCompilerEvent *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ProcessResourceNameScriptCompilerEvent < Ogre::Ogre::ScriptCompilerEvent

  Proxy of C++ Ogre::ProcessResourceNameScriptCompilerEvent class


*/
swig_class SwigClassProcessResourceNameScriptCompilerEvent;


/*
  Document-method: Ogre::ResourceType.TEXTURE

  call-seq:
    TEXTURE -> int

A class method.

*/

/*
  Document-method: Ogre::ResourceType.MATERIAL

  call-seq:
    MATERIAL -> int

A class method.

*/

/*
  Document-method: Ogre::ResourceType.GPU_PROGRAM

  call-seq:
    GPU_PROGRAM -> int

A class method.

*/

/*
  Document-method: Ogre::ResourceType.COMPOSITOR

  call-seq:
    COMPOSITOR -> int

A class method.

*/

/*
  Document-method: Ogre::ProcessResourceNameScriptCompilerEvent.mResourceType

  call-seq:
    mResourceType -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::ProcessResourceNameScriptCompilerEvent.mResourceType=

  call-seq:
    mResourceType=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::ProcessResourceNameScriptCompilerEvent.mName

  call-seq:
    mName -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ProcessResourceNameScriptCompilerEvent.mName=

  call-seq:
    mName=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ProcessResourceNameScriptCompilerEvent.eventType

  call-seq:
    eventType -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ProcessResourceNameScriptCompilerEvent.eventType=

  call-seq:
    eventType=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::ProcessResourceNameScriptCompilerEvent.ProcessResourceNameScriptCompilerEvent_eventType

  call-seq:
    ProcessResourceNameScriptCompilerEvent_eventType -> String

Get value of attribute.

*/
SWIGINTERN VALUE
_wrap_ProcessResourceNameScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::ProcessResourceNameScriptCompilerEvent::eventType));
  return _val;
}



/*
  Document-method: Ogre::ProcessResourceNameScriptCompilerEvent.ProcessResourceNameScriptCompilerEvent_eventType=

  call-seq:
    ProcessResourceNameScriptCompilerEvent_eventType=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::ProcessResourceNameScriptCompilerEvent.new

  call-seq:
    ProcessResourceNameScriptCompilerEvent.new(ResourceType resourceType, String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ProcessResourceNameScriptCompilerEvent *)new Ogre::ProcessResourceNameScriptCompilerEvent(arg1,(Ogre::String const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::ProcessNameExclusionScriptCompilerEvent < Ogre::Ogre::ScriptCompilerEvent

  Proxy of C++ Ogre::ProcessNameExclusionScriptCompilerEvent class


*/
swig_class SwigClassProcessNameExclusionScriptCompilerEvent;


/*
  Document-method: Ogre::ProcessNameExclusionScriptCompilerEvent.mClass

  call-seq:
    mClass -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ProcessNameExclusionScriptCompilerEvent.mClass=

  call-seq:
    mClass=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ProcessNameExclusionScriptCompilerEvent.mParent

  call-seq:
    mParent -> AbstractNode

Get value of attribute.

*/

/*
  Document-method: Ogre::ProcessNameExclusionScriptCompilerEvent.mParent=

  call-seq:
    mParent=(x) -> AbstractNode

Set new value for attribute.

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



/*
  Document-method: Ogre::ProcessNameExclusionScriptCompilerEvent.eventType

  call-seq:
    eventType -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ProcessNameExclusionScriptCompilerEvent.eventType=

  call-seq:
    eventType=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::ProcessNameExclusionScriptCompilerEvent.ProcessNameExclusionScriptCompilerEvent_eventType

  call-seq:
    ProcessNameExclusionScriptCompilerEvent_eventType -> String

Get value of attribute.

*/
SWIGINTERN VALUE
_wrap_ProcessNameExclusionScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::ProcessNameExclusionScriptCompilerEvent::eventType));
  return _val;
}



/*
  Document-method: Ogre::ProcessNameExclusionScriptCompilerEvent.ProcessNameExclusionScriptCompilerEvent_eventType=

  call-seq:
    ProcessNameExclusionScriptCompilerEvent_eventType=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::ProcessNameExclusionScriptCompilerEvent.new

  call-seq:
    ProcessNameExclusionScriptCompilerEvent.new(String cls, AbstractNode parent)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::ProcessNameExclusionScriptCompilerEvent *)new Ogre::ProcessNameExclusionScriptCompilerEvent((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::CreateMaterialScriptCompilerEvent < Ogre::Ogre::ScriptCompilerEvent

  Proxy of C++ Ogre::CreateMaterialScriptCompilerEvent class


*/
swig_class SwigClassCreateMaterialScriptCompilerEvent;


/*
  Document-method: Ogre::CreateMaterialScriptCompilerEvent.mFile

  call-seq:
    mFile -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateMaterialScriptCompilerEvent.mFile=

  call-seq:
    mFile=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateMaterialScriptCompilerEvent.mName

  call-seq:
    mName -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateMaterialScriptCompilerEvent.mName=

  call-seq:
    mName=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateMaterialScriptCompilerEvent.mResourceGroup

  call-seq:
    mResourceGroup -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateMaterialScriptCompilerEvent.mResourceGroup=

  call-seq:
    mResourceGroup=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateMaterialScriptCompilerEvent.eventType

  call-seq:
    eventType -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateMaterialScriptCompilerEvent.eventType=

  call-seq:
    eventType=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::CreateMaterialScriptCompilerEvent.CreateMaterialScriptCompilerEvent_eventType

  call-seq:
    CreateMaterialScriptCompilerEvent_eventType -> String

Get value of attribute.

*/
SWIGINTERN VALUE
_wrap_CreateMaterialScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::CreateMaterialScriptCompilerEvent::eventType));
  return _val;
}



/*
  Document-method: Ogre::CreateMaterialScriptCompilerEvent.CreateMaterialScriptCompilerEvent_eventType=

  call-seq:
    CreateMaterialScriptCompilerEvent_eventType=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::CreateMaterialScriptCompilerEvent.new

  call-seq:
    CreateMaterialScriptCompilerEvent.new(String file, String name, String resourceGroup)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::CreateMaterialScriptCompilerEvent *)new Ogre::CreateMaterialScriptCompilerEvent((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::CreateGpuProgramScriptCompilerEvent < Ogre::Ogre::ScriptCompilerEvent

  Proxy of C++ Ogre::CreateGpuProgramScriptCompilerEvent class


*/
swig_class SwigClassCreateGpuProgramScriptCompilerEvent;


/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.mFile

  call-seq:
    mFile -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.mFile=

  call-seq:
    mFile=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.mName

  call-seq:
    mName -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.mName=

  call-seq:
    mName=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.mResourceGroup

  call-seq:
    mResourceGroup -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.mResourceGroup=

  call-seq:
    mResourceGroup=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.mSource

  call-seq:
    mSource -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.mSource=

  call-seq:
    mSource=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.mSyntax

  call-seq:
    mSyntax -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.mSyntax=

  call-seq:
    mSyntax=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.mProgramType

  call-seq:
    mProgramType -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.mProgramType=

  call-seq:
    mProgramType=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.eventType

  call-seq:
    eventType -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.eventType=

  call-seq:
    eventType=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.CreateGpuProgramScriptCompilerEvent_eventType

  call-seq:
    CreateGpuProgramScriptCompilerEvent_eventType -> String

Get value of attribute.

*/
SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::CreateGpuProgramScriptCompilerEvent::eventType));
  return _val;
}



/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.CreateGpuProgramScriptCompilerEvent_eventType=

  call-seq:
    CreateGpuProgramScriptCompilerEvent_eventType=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::CreateGpuProgramScriptCompilerEvent.new

  call-seq:
    CreateGpuProgramScriptCompilerEvent.new(String file, String name, String resourceGroup, String source, 
    String syntax, GpuProgramType programType)

Class constructor.

*/
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);
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  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;
}


/*
  Document-class: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent < Ogre::Ogre::ScriptCompilerEvent

  Proxy of C++ Ogre::CreateHighLevelGpuProgramScriptCompilerEvent class


*/
swig_class SwigClassCreateHighLevelGpuProgramScriptCompilerEvent;


/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.mFile

  call-seq:
    mFile -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.mFile=

  call-seq:
    mFile=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.mName

  call-seq:
    mName -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.mName=

  call-seq:
    mName=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.mResourceGroup

  call-seq:
    mResourceGroup -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.mResourceGroup=

  call-seq:
    mResourceGroup=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.mSource

  call-seq:
    mSource -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.mSource=

  call-seq:
    mSource=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.mLanguage

  call-seq:
    mLanguage -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.mLanguage=

  call-seq:
    mLanguage=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.mProgramType

  call-seq:
    mProgramType -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.mProgramType=

  call-seq:
    mProgramType=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.eventType

  call-seq:
    eventType -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.eventType=

  call-seq:
    eventType=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.CreateHighLevelGpuProgramScriptCompilerEvent_eventType

  call-seq:
    CreateHighLevelGpuProgramScriptCompilerEvent_eventType -> String

Get value of attribute.

*/
SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::CreateHighLevelGpuProgramScriptCompilerEvent::eventType));
  return _val;
}



/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.CreateHighLevelGpuProgramScriptCompilerEvent_eventType=

  call-seq:
    CreateHighLevelGpuProgramScriptCompilerEvent_eventType=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::CreateHighLevelGpuProgramScriptCompilerEvent.new

  call-seq:
    CreateHighLevelGpuProgramScriptCompilerEvent.new(String file, String name, String resourceGroup, String source, 
    String language, GpuProgramType programType)

Class constructor.

*/
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);
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  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;
}


/*
  Document-class: Ogre::CreateGpuSharedParametersScriptCompilerEvent < Ogre::Ogre::ScriptCompilerEvent

  Proxy of C++ Ogre::CreateGpuSharedParametersScriptCompilerEvent class


*/
swig_class SwigClassCreateGpuSharedParametersScriptCompilerEvent;


/*
  Document-method: Ogre::CreateGpuSharedParametersScriptCompilerEvent.mFile

  call-seq:
    mFile -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateGpuSharedParametersScriptCompilerEvent.mFile=

  call-seq:
    mFile=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateGpuSharedParametersScriptCompilerEvent.mName

  call-seq:
    mName -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateGpuSharedParametersScriptCompilerEvent.mName=

  call-seq:
    mName=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateGpuSharedParametersScriptCompilerEvent.mResourceGroup

  call-seq:
    mResourceGroup -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateGpuSharedParametersScriptCompilerEvent.mResourceGroup=

  call-seq:
    mResourceGroup=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateGpuSharedParametersScriptCompilerEvent.eventType

  call-seq:
    eventType -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateGpuSharedParametersScriptCompilerEvent.eventType=

  call-seq:
    eventType=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::CreateGpuSharedParametersScriptCompilerEvent.CreateGpuSharedParametersScriptCompilerEvent_eventType

  call-seq:
    CreateGpuSharedParametersScriptCompilerEvent_eventType -> String

Get value of attribute.

*/
SWIGINTERN VALUE
_wrap_CreateGpuSharedParametersScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::CreateGpuSharedParametersScriptCompilerEvent::eventType));
  return _val;
}



/*
  Document-method: Ogre::CreateGpuSharedParametersScriptCompilerEvent.CreateGpuSharedParametersScriptCompilerEvent_eventType=

  call-seq:
    CreateGpuSharedParametersScriptCompilerEvent_eventType=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::CreateGpuSharedParametersScriptCompilerEvent.new

  call-seq:
    CreateGpuSharedParametersScriptCompilerEvent.new(String file, String name, String resourceGroup)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::CreateGpuSharedParametersScriptCompilerEvent *)new Ogre::CreateGpuSharedParametersScriptCompilerEvent((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::CreateParticleSystemScriptCompilerEvent < Ogre::Ogre::ScriptCompilerEvent

  Proxy of C++ Ogre::CreateParticleSystemScriptCompilerEvent class


*/
swig_class SwigClassCreateParticleSystemScriptCompilerEvent;


/*
  Document-method: Ogre::CreateParticleSystemScriptCompilerEvent.mFile

  call-seq:
    mFile -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateParticleSystemScriptCompilerEvent.mFile=

  call-seq:
    mFile=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateParticleSystemScriptCompilerEvent.mName

  call-seq:
    mName -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateParticleSystemScriptCompilerEvent.mName=

  call-seq:
    mName=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateParticleSystemScriptCompilerEvent.mResourceGroup

  call-seq:
    mResourceGroup -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateParticleSystemScriptCompilerEvent.mResourceGroup=

  call-seq:
    mResourceGroup=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateParticleSystemScriptCompilerEvent.eventType

  call-seq:
    eventType -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateParticleSystemScriptCompilerEvent.eventType=

  call-seq:
    eventType=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::CreateParticleSystemScriptCompilerEvent.CreateParticleSystemScriptCompilerEvent_eventType

  call-seq:
    CreateParticleSystemScriptCompilerEvent_eventType -> String

Get value of attribute.

*/
SWIGINTERN VALUE
_wrap_CreateParticleSystemScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::CreateParticleSystemScriptCompilerEvent::eventType));
  return _val;
}



/*
  Document-method: Ogre::CreateParticleSystemScriptCompilerEvent.CreateParticleSystemScriptCompilerEvent_eventType=

  call-seq:
    CreateParticleSystemScriptCompilerEvent_eventType=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::CreateParticleSystemScriptCompilerEvent.new

  call-seq:
    CreateParticleSystemScriptCompilerEvent.new(String file, String name, String resourceGroup)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::CreateParticleSystemScriptCompilerEvent *)new Ogre::CreateParticleSystemScriptCompilerEvent((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::CreateCompositorScriptCompilerEvent < Ogre::Ogre::ScriptCompilerEvent

  Proxy of C++ Ogre::CreateCompositorScriptCompilerEvent class


*/
swig_class SwigClassCreateCompositorScriptCompilerEvent;


/*
  Document-method: Ogre::CreateCompositorScriptCompilerEvent.mFile

  call-seq:
    mFile -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateCompositorScriptCompilerEvent.mFile=

  call-seq:
    mFile=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateCompositorScriptCompilerEvent.mName

  call-seq:
    mName -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateCompositorScriptCompilerEvent.mName=

  call-seq:
    mName=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateCompositorScriptCompilerEvent.mResourceGroup

  call-seq:
    mResourceGroup -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateCompositorScriptCompilerEvent.mResourceGroup=

  call-seq:
    mResourceGroup=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::CreateCompositorScriptCompilerEvent.eventType

  call-seq:
    eventType -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::CreateCompositorScriptCompilerEvent.eventType=

  call-seq:
    eventType=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::CreateCompositorScriptCompilerEvent.CreateCompositorScriptCompilerEvent_eventType

  call-seq:
    CreateCompositorScriptCompilerEvent_eventType -> String

Get value of attribute.

*/
SWIGINTERN VALUE
_wrap_CreateCompositorScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::CreateCompositorScriptCompilerEvent::eventType));
  return _val;
}



/*
  Document-method: Ogre::CreateCompositorScriptCompilerEvent.CreateCompositorScriptCompilerEvent_eventType=

  call-seq:
    CreateCompositorScriptCompilerEvent_eventType=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::CreateCompositorScriptCompilerEvent.new

  call-seq:
    CreateCompositorScriptCompilerEvent.new(String file, String name, String resourceGroup)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::CreateCompositorScriptCompilerEvent *)new Ogre::CreateCompositorScriptCompilerEvent((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::ParticleSystem < Ogre::Ogre::StringInterface, Ogre::Ogre::MovableObject

  Proxy of C++ Ogre::ParticleSystem class


*/
swig_class SwigClassParticleSystem;


/*
  Document-method: Ogre::ParticleSystem.new

  call-seq:
    ParticleSystem.new
    ParticleSystem.new(String name, String resourceGroupName)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ParticleSystem *)new Ogre::ParticleSystem();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      result = (Ogre::ParticleSystem *)new Ogre::ParticleSystem((Ogre::String const &)*arg1,(Ogre::String const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::ParticleSystem.set_renderer

  call-seq:
    set_renderer(String typeName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_renderer(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;
  }
  {
    try {
      (arg1)->setRenderer((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_renderer

  call-seq:
    get_renderer -> ParticleSystemRenderer

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_renderer(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);
  {
    try {
      result = (Ogre::ParticleSystemRenderer *)((Ogre::ParticleSystem const *)arg1)->getRenderer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystemRenderer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_renderer_name

  call-seq:
    get_renderer_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_renderer_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ParticleSystem const *)arg1)->getRendererName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.add_emitter

  call-seq:
    add_emitter(String emitterType) -> ParticleEmitter

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_add_emitter(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;
  }
  {
    try {
      result = (Ogre::ParticleEmitter *)(arg1)->addEmitter((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleEmitter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_emitter

  call-seq:
    get_emitter(unsigned short index) -> ParticleEmitter

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_emitter(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);
  {
    try {
      result = (Ogre::ParticleEmitter *)((Ogre::ParticleSystem const *)arg1)->getEmitter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleEmitter, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_num_emitters

  call-seq:
    get_num_emitters -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_num_emitters(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);
  {
    try {
      result = (unsigned short)((Ogre::ParticleSystem const *)arg1)->getNumEmitters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.remove_emitter

  call-seq:
    remove_emitter(unsigned short index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_remove_emitter(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);
  {
    try {
      (arg1)->removeEmitter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.remove_all_emitters

  call-seq:
    remove_all_emitters

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_remove_all_emitters(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);
  {
    try {
      (arg1)->removeAllEmitters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.add_affector

  call-seq:
    add_affector(String affectorType) -> ParticleAffector

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_add_affector(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;
  }
  {
    try {
      result = (Ogre::ParticleAffector *)(arg1)->addAffector((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleAffector, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_affector

  call-seq:
    get_affector(unsigned short index) -> ParticleAffector

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_affector(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);
  {
    try {
      result = (Ogre::ParticleAffector *)((Ogre::ParticleSystem const *)arg1)->getAffector(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleAffector, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_num_affectors

  call-seq:
    get_num_affectors -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_num_affectors(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);
  {
    try {
      result = (unsigned short)((Ogre::ParticleSystem const *)arg1)->getNumAffectors();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.remove_affector

  call-seq:
    remove_affector(unsigned short index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_remove_affector(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);
  {
    try {
      (arg1)->removeAffector(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.remove_all_affectors

  call-seq:
    remove_all_affectors

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_remove_all_affectors(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);
  {
    try {
      (arg1)->removeAllAffectors();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_num_particles

  call-seq:
    get_num_particles -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_num_particles(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);
  {
    try {
      result = ((Ogre::ParticleSystem const *)arg1)->getNumParticles();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.create_particle

  call-seq:
    create_particle -> Particle

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_create_particle(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);
  {
    try {
      result = (Ogre::Particle *)(arg1)->createParticle();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Particle, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.create_emitter_particle

  call-seq:
    create_emitter_particle(String emitterName) -> Particle

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_create_emitter_particle(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;
  }
  {
    try {
      result = (Ogre::Particle *)(arg1)->createEmitterParticle((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Particle, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_particle

  call-seq:
    get_particle(size_t index) -> Particle

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_particle(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);
  {
    try {
      result = (Ogre::Particle *)(arg1)->getParticle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Particle, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_particle_quota

  call-seq:
    get_particle_quota -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_particle_quota(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);
  {
    try {
      result = ((Ogre::ParticleSystem const *)arg1)->getParticleQuota();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_particle_quota

  call-seq:
    set_particle_quota(size_t quota)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_particle_quota(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);
  {
    try {
      (arg1)->setParticleQuota(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_emitted_emitter_quota

  call-seq:
    get_emitted_emitter_quota -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_emitted_emitter_quota(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);
  {
    try {
      result = ((Ogre::ParticleSystem const *)arg1)->getEmittedEmitterQuota();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_emitted_emitter_quota

  call-seq:
    set_emitted_emitter_quota(size_t quota)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_emitted_emitter_quota(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);
  {
    try {
      (arg1)->setEmittedEmitterQuota(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem._update

  call-seq:
    _update(Real timeElapsed)

An instance method.

*/
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);
  {
    try {
      (arg1)->_update(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem._get_iterator

  call-seq:
    _get_iterator -> ParticleIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem__get_iterator(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);
  {
    try {
      result = (arg1)->_getIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ParticleIterator(static_cast< const Ogre::ParticleIterator& >(result))), SWIGTYPE_p_Ogre__ParticleIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_material_name

  call-seq:
    set_material_name(String name, String groupName=AUTODETECT_RESOURCE_GROUP_NAME)
    set_material_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystem_set_material_name(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_set_material_name__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_set_material_name__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystem.set_material_name", 
    "    void ParticleSystem.set_material_name(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    void ParticleSystem.set_material_name(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_material_name

  call-seq:
    get_material_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_material_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ParticleSystem const *)arg1)->getMaterialName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem._notify_current_camera

  call-seq:
    _notify_current_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem__notify_current_camera(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);
  {
    try {
      (arg1)->_notifyCurrentCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem._notify_attached

  call-seq:
    _notify_attached(Node parent, bool isTagPoint=false)
    _notify_attached(Node parent)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem__notify_attached__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);
  {
    try {
      (arg1)->_notifyAttached(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystem__notify_attached(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__notify_attached__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__notify_attached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystem._notify_attached", 
    "    void ParticleSystem._notify_attached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void ParticleSystem._notify_attached(Ogre::Node *parent)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::ParticleSystem const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleSystem const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem._update_render_queue

  call-seq:
    _update_render_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem__update_render_queue(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);
  {
    try {
      (arg1)->_updateRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystem_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystem.visit_renderables", 
    "    void ParticleSystem.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void ParticleSystem.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.fast_forward

  call-seq:
    fast_forward(Real time, Real interval=0.1)
    fast_forward(Real time)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_fast_forward__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);
  {
    try {
      (arg1)->fastForward(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_fast_forward__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);
  {
    try {
      (arg1)->fastForward(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystem_fast_forward(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_fast_forward__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_fast_forward__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystem.fast_forward", 
    "    void ParticleSystem.fast_forward(Ogre::Real time, Ogre::Real interval)\n"
    "    void ParticleSystem.fast_forward(Ogre::Real time)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_speed_factor

  call-seq:
    set_speed_factor(Real speedFactor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_speed_factor(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);
  {
    try {
      (arg1)->setSpeedFactor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_speed_factor

  call-seq:
    get_speed_factor -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_speed_factor(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleSystem const *)arg1)->getSpeedFactor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_iteration_interval

  call-seq:
    set_iteration_interval(Real iterationInterval)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_iteration_interval(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);
  {
    try {
      (arg1)->setIterationInterval(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_iteration_interval

  call-seq:
    get_iteration_interval -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_iteration_interval(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleSystem const *)arg1)->getIterationInterval();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_default_iteration_interval

  call-seq:
    set_default_iteration_interval(Real iterationInterval)

A class method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_default_iteration_interval(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);
  {
    try {
      Ogre::ParticleSystem::setDefaultIterationInterval(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_default_iteration_interval

  call-seq:
    get_default_iteration_interval -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_default_iteration_interval(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;
  }
  {
    try {
      result = (Ogre::Real)Ogre::ParticleSystem::getDefaultIterationInterval();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_non_visible_update_timeout

  call-seq:
    set_non_visible_update_timeout(Real timeout)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_non_visible_update_timeout(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);
  {
    try {
      (arg1)->setNonVisibleUpdateTimeout(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_non_visible_update_timeout

  call-seq:
    get_non_visible_update_timeout -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_non_visible_update_timeout(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleSystem const *)arg1)->getNonVisibleUpdateTimeout();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_default_non_visible_update_timeout

  call-seq:
    set_default_non_visible_update_timeout(Real timeout)

A class method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_default_non_visible_update_timeout(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);
  {
    try {
      Ogre::ParticleSystem::setDefaultNonVisibleUpdateTimeout(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_default_non_visible_update_timeout

  call-seq:
    get_default_non_visible_update_timeout -> Real

A class method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_default_non_visible_update_timeout(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;
  }
  {
    try {
      result = (Ogre::Real)Ogre::ParticleSystem::getDefaultNonVisibleUpdateTimeout();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ParticleSystem const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem._notify_particle_resized

  call-seq:
    _notify_particle_resized

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem__notify_particle_resized(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);
  {
    try {
      (arg1)->_notifyParticleResized();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem._notify_particle_rotated

  call-seq:
    _notify_particle_rotated

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem__notify_particle_rotated(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);
  {
    try {
      (arg1)->_notifyParticleRotated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_default_dimensions

  call-seq:
    set_default_dimensions(Real width, Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_default_dimensions(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);
  {
    try {
      (arg1)->setDefaultDimensions(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_default_width

  call-seq:
    set_default_width(Real width)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_default_width(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);
  {
    try {
      (arg1)->setDefaultWidth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_default_width

  call-seq:
    get_default_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_default_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleSystem const *)arg1)->getDefaultWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_default_height

  call-seq:
    set_default_height(Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_default_height(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);
  {
    try {
      (arg1)->setDefaultHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_default_height

  call-seq:
    get_default_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_default_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleSystem const *)arg1)->getDefaultHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_cull_individually

  call-seq:
    get_cull_individually -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_cull_individually(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);
  {
    try {
      result = (bool)((Ogre::ParticleSystem const *)arg1)->getCullIndividually();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_cull_individually

  call-seq:
    set_cull_individually(bool cullIndividual)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_cull_individually(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);
  {
    try {
      (arg1)->setCullIndividually(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_resource_group_name

  call-seq:
    get_resource_group_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_resource_group_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ParticleSystem const *)arg1)->getResourceGroupName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_origin

  call-seq:
    get_origin -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_origin(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ParticleSystem const *)arg1)->getOrigin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem._notify_origin

  call-seq:
    _notify_origin(String origin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem__notify_origin(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;
  }
  {
    try {
      (arg1)->_notifyOrigin((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_render_queue_group

  call-seq:
    set_render_queue_group(uint8 queueID)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_render_queue_group(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);
  {
    try {
      (arg1)->setRenderQueueGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_render_queue_group_and_priority

  call-seq:
    set_render_queue_group_and_priority(uint8 queueID, ushort priority)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_render_queue_group_and_priority(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setRenderQueueGroupAndPriority", 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","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);
  {
    try {
      (arg1)->setRenderQueueGroupAndPriority(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_sorting_enabled

  call-seq:
    set_sorting_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_sorting_enabled(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);
  {
    try {
      (arg1)->setSortingEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_sorting_enabled

  call-seq:
    get_sorting_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_sorting_enabled(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);
  {
    try {
      result = (bool)((Ogre::ParticleSystem const *)arg1)->getSortingEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_bounds

  call-seq:
    set_bounds(AxisAlignedBox aabb)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_bounds(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);
  {
    try {
      (arg1)->setBounds((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_bounds_auto_updated

  call-seq:
    set_bounds_auto_updated(bool autoUpdate, Real stopIn=0.0)
    set_bounds_auto_updated(bool autoUpdate)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_bounds_auto_updated__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);
  {
    try {
      (arg1)->setBoundsAutoUpdated(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_set_bounds_auto_updated__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);
  {
    try {
      (arg1)->setBoundsAutoUpdated(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystem_set_bounds_auto_updated(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_set_bounds_auto_updated__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_set_bounds_auto_updated__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystem.set_bounds_auto_updated", 
    "    void ParticleSystem.set_bounds_auto_updated(bool autoUpdate, Ogre::Real stopIn)\n"
    "    void ParticleSystem.set_bounds_auto_updated(bool autoUpdate)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_keep_particles_in_local_space

  call-seq:
    set_keep_particles_in_local_space(bool keepLocal)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_keep_particles_in_local_space(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);
  {
    try {
      (arg1)->setKeepParticlesInLocalSpace(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_keep_particles_in_local_space

  call-seq:
    get_keep_particles_in_local_space -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_keep_particles_in_local_space(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);
  {
    try {
      result = (bool)((Ogre::ParticleSystem const *)arg1)->getKeepParticlesInLocalSpace();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem._update_bounds

  call-seq:
    _update_bounds

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem__update_bounds(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);
  {
    try {
      (arg1)->_updateBounds();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.set_emitting

  call-seq:
    set_emitting(bool v)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_set_emitting(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);
  {
    try {
      (arg1)->setEmitting(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_emitting

  call-seq:
    get_emitting -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_emitting(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);
  {
    try {
      result = (bool)((Ogre::ParticleSystem const *)arg1)->getEmitting();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.get_type_flags

  call-seq:
    get_type_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystem_get_type_flags(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::ParticleSystem const *)arg1)->getTypeFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ParticleSystemManager < Ogre::Ogre::ScriptLoader

  Proxy of C++ Ogre::ParticleSystemManager class


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


/*
  Document-method: Ogre::ParticleSystemManager.new

  call-seq:
    ParticleSystemManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ParticleSystemManager *)new Ogre::ParticleSystemManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleSystemManager(Ogre::ParticleSystemManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ParticleSystemManager.add_emitter_factory

  call-seq:
    add_emitter_factory(ParticleEmitterFactory factory)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_add_emitter_factory(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);
  {
    try {
      (arg1)->addEmitterFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.add_affector_factory

  call-seq:
    add_affector_factory(ParticleAffectorFactory factory)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_add_affector_factory(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);
  {
    try {
      (arg1)->addAffectorFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.add_renderer_factory

  call-seq:
    add_renderer_factory(ParticleSystemRendererFactory factory)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_add_renderer_factory(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);
  {
    try {
      (arg1)->addRendererFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.add_template

  call-seq:
    add_template(String name, ParticleSystem sysTemplate)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_add_template(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);
  {
    try {
      (arg1)->addTemplate((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.remove_template

  call-seq:
    remove_template(String name, bool deleteTemplate=true)
    remove_template(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_remove_template__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);
  {
    try {
      (arg1)->removeTemplate((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_remove_template__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;
  }
  {
    try {
      (arg1)->removeTemplate((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystemManager_remove_template(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_remove_template__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_remove_template__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystemManager.remove_template", 
    "    void ParticleSystemManager.remove_template(Ogre::String const &name, bool deleteTemplate)\n"
    "    void ParticleSystemManager.remove_template(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.remove_all_templates

  call-seq:
    remove_all_templates(bool deleteTemplate=true)
    remove_all_templates

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_remove_all_templates__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);
  {
    try {
      (arg1)->removeAllTemplates(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_remove_all_templates__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);
  {
    try {
      (arg1)->removeAllTemplates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystemManager_remove_all_templates(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_remove_all_templates__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_remove_all_templates__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ParticleSystemManager.remove_all_templates", 
    "    void ParticleSystemManager.remove_all_templates(bool deleteTemplate)\n"
    "    void ParticleSystemManager.remove_all_templates()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.remove_templates_by_resource_group

  call-seq:
    remove_templates_by_resource_group(String resourceGroup)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_remove_templates_by_resource_group(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;
  }
  {
    try {
      (arg1)->removeTemplatesByResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.create_template

  call-seq:
    create_template(String name, String resourceGroup) -> ParticleSystem

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_create_template(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;
  }
  {
    try {
      result = (Ogre::ParticleSystem *)(arg1)->createTemplate((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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;
}



/*
  Document-method: Ogre::ParticleSystemManager.get_template

  call-seq:
    get_template(String name) -> ParticleSystem

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_get_template(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;
  }
  {
    try {
      result = (Ogre::ParticleSystem *)(arg1)->getTemplate((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager._create_emitter

  call-seq:
    _create_emitter(String emitterType, ParticleSystem psys) -> ParticleEmitter

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager__create_emitter(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);
  {
    try {
      result = (Ogre::ParticleEmitter *)(arg1)->_createEmitter((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleEmitter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager._destroy_emitter

  call-seq:
    _destroy_emitter(ParticleEmitter emitter)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager__destroy_emitter(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);
  {
    try {
      (arg1)->_destroyEmitter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager._create_affector

  call-seq:
    _create_affector(String affectorType, ParticleSystem psys) -> ParticleAffector

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager__create_affector(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);
  {
    try {
      result = (Ogre::ParticleAffector *)(arg1)->_createAffector((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleAffector, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager._destroy_affector

  call-seq:
    _destroy_affector(ParticleAffector affector)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager__destroy_affector(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);
  {
    try {
      (arg1)->_destroyAffector(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager._create_renderer

  call-seq:
    _create_renderer(String rendererType) -> ParticleSystemRenderer

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager__create_renderer(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;
  }
  {
    try {
      result = (Ogre::ParticleSystemRenderer *)(arg1)->_createRenderer((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager._destroy_renderer

  call-seq:
    _destroy_renderer(ParticleSystemRenderer renderer)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager__destroy_renderer(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);
  {
    try {
      (arg1)->_destroyRenderer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager._initialise

  call-seq:
    _initialise

An instance method.

*/
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);
  {
    try {
      (arg1)->_initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.get_script_patterns

  call-seq:
    get_script_patterns -> StringVector

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_get_script_patterns(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);
  {
    try {
      result = (Ogre::StringVector *) &((Ogre::ParticleSystemManager const *)arg1)->getScriptPatterns();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.parse_script

  call-seq:
    parse_script(DataStreamPtr stream, String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_parse_script(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;
  }
  {
    try {
      (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.get_loading_order

  call-seq:
    get_loading_order -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_get_loading_order(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);
  {
    try {
      result = (Ogre::Real)((Ogre::ParticleSystemManager const *)arg1)->getLoadingOrder();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.get_affector_factory_iterator

  call-seq:
    get_affector_factory_iterator -> ParticleAffectorFactoryIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_get_affector_factory_iterator(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);
  {
    try {
      result = (arg1)->getAffectorFactoryIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ParticleSystemManager.get_emitter_factory_iterator

  call-seq:
    get_emitter_factory_iterator -> ParticleEmitterFactoryIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_get_emitter_factory_iterator(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);
  {
    try {
      result = (arg1)->getEmitterFactoryIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ParticleSystemManager.get_renderer_factory_iterator

  call-seq:
    get_renderer_factory_iterator -> ParticleRendererFactoryIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_get_renderer_factory_iterator(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);
  {
    try {
      result = (arg1)->getRendererFactoryIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ParticleSystemManager.get_template_iterator

  call-seq:
    get_template_iterator -> ParticleSystemTemplateIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_get_template_iterator(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);
  {
    try {
      result = (arg1)->getTemplateIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ParticleSystemManager._get_factory

  call-seq:
    _get_factory -> ParticleSystemFactory

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager__get_factory(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);
  {
    try {
      result = (Ogre::ParticleSystemFactory *)(arg1)->_getFactory();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystemFactory, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.get_singleton

  call-seq:
    get_singleton -> ParticleSystemManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::ParticleSystemManager *) &Ogre::ParticleSystemManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystemManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> ParticleSystemManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::ParticleSystemManager *)Ogre::ParticleSystemManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystemManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ParticleSystemFactory < Ogre::Ogre::MovableObjectFactory

  Proxy of C++ Ogre::ParticleSystemFactory class


*/
swig_class SwigClassParticleSystemFactory;

SWIGINTERN void
free_Ogre_ParticleSystemFactory(Ogre::ParticleSystemFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ParticleSystemFactory.FACTORY_TYPE_NAME

  call-seq:
    FACTORY_TYPE_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ParticleSystemFactory.FACTORY_TYPE_NAME=

  call-seq:
    FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::ParticleSystemFactory.ParticleSystemFactory_FACTORY_TYPE_NAME

  call-seq:
    ParticleSystemFactory_FACTORY_TYPE_NAME -> String

Get value of attribute.

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



/*
  Document-method: Ogre::ParticleSystemFactory.ParticleSystemFactory_FACTORY_TYPE_NAME=

  call-seq:
    ParticleSystemFactory_FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ParticleSystemFactory.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemFactory_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::ParticleSystemFactory const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemFactory.destroy_instance

  call-seq:
    destroy_instance(MovableObject obj)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ParticleSystemFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Pass

  Proxy of C++ Ogre::Pass class


*/
swig_class SwigClassPass;


/*
  Document-method: Ogre::Pass.new

  call-seq:
    Pass.new(Technique parent, unsigned short index)
    Pass.new(Technique parent, unsigned short index, Pass oth)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Pass *)new Ogre::Pass(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::Pass *)new Ogre::Pass(arg1,arg2,(Ogre::Pass const &)*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::Pass.is_programmable

  call-seq:
    is_programmable -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_is_programmable(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->isProgrammable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.has_vertex_program

  call-seq:
    has_vertex_program -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_has_vertex_program(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->hasVertexProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.has_fragment_program

  call-seq:
    has_fragment_program -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_has_fragment_program(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->hasFragmentProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.has_geometry_program

  call-seq:
    has_geometry_program -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_has_geometry_program(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->hasGeometryProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.has_shadow_caster_vertex_program

  call-seq:
    has_shadow_caster_vertex_program -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_has_shadow_caster_vertex_program(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->hasShadowCasterVertexProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.has_shadow_caster_fragment_program

  call-seq:
    has_shadow_caster_fragment_program -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_has_shadow_caster_fragment_program(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->hasShadowCasterFragmentProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.has_shadow_receiver_vertex_program

  call-seq:
    has_shadow_receiver_vertex_program -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_has_shadow_receiver_vertex_program(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->hasShadowReceiverVertexProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.has_shadow_receiver_fragment_program

  call-seq:
    has_shadow_receiver_fragment_program -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_has_shadow_receiver_fragment_program(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->hasShadowReceiverFragmentProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_index

  call-seq:
    get_index -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_index(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);
  {
    try {
      result = (unsigned short)((Ogre::Pass const *)arg1)->getIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_name

  call-seq:
    set_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_name(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;
  }
  {
    try {
      (arg1)->setName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_ambient

  call-seq:
    set_ambient(Real red, Real green, Real blue)
    set_ambient(ColourValue ambient)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_ambient__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);
  {
    try {
      (arg1)->setAmbient(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_ambient__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);
  {
    try {
      (arg1)->setAmbient((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_ambient(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_set_ambient__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_set_ambient__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Pass.set_ambient", 
    "    void Pass.set_ambient(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Pass.set_ambient(Ogre::ColourValue const &ambient)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_diffuse

  call-seq:
    set_diffuse(Real red, Real green, Real blue, Real alpha)
    set_diffuse(ColourValue diffuse)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_diffuse__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);
  {
    try {
      (arg1)->setDiffuse(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_diffuse__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);
  {
    try {
      (arg1)->setDiffuse((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_diffuse(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_set_diffuse__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_set_diffuse__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Pass.set_diffuse", 
    "    void Pass.set_diffuse(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Pass.set_diffuse(Ogre::ColourValue const &diffuse)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_specular

  call-seq:
    set_specular(Real red, Real green, Real blue, Real alpha)
    set_specular(ColourValue specular)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_specular__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);
  {
    try {
      (arg1)->setSpecular(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_specular__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);
  {
    try {
      (arg1)->setSpecular((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_specular(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_set_specular__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_set_specular__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Pass.set_specular", 
    "    void Pass.set_specular(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Pass.set_specular(Ogre::ColourValue const &specular)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_shininess

  call-seq:
    set_shininess(Real val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_shininess(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);
  {
    try {
      (arg1)->setShininess(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_self_illumination

  call-seq:
    set_self_illumination(Real red, Real green, Real blue)
    set_self_illumination(ColourValue selfIllum)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_self_illumination__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);
  {
    try {
      (arg1)->setSelfIllumination(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_emissive

  call-seq:
    set_emissive(Real red, Real green, Real blue)
    set_emissive(ColourValue emissive)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_emissive__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);
  {
    try {
      (arg1)->setEmissive(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_self_illumination

  call-seq:
    set_self_illumination(Real red, Real green, Real blue)
    set_self_illumination(ColourValue selfIllum)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_self_illumination__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);
  {
    try {
      (arg1)->setSelfIllumination((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_self_illumination(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_set_self_illumination__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_set_self_illumination__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Pass.set_self_illumination", 
    "    void Pass.set_self_illumination(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Pass.set_self_illumination(Ogre::ColourValue const &selfIllum)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_emissive

  call-seq:
    set_emissive(Real red, Real green, Real blue)
    set_emissive(ColourValue emissive)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_emissive__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);
  {
    try {
      (arg1)->setEmissive((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_emissive(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_set_emissive__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_set_emissive__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Pass.set_emissive", 
    "    void Pass.set_emissive(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Pass.set_emissive(Ogre::ColourValue const &emissive)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_vertex_colour_tracking

  call-seq:
    set_vertex_colour_tracking(TrackVertexColourType tracking)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_vertex_colour_tracking(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);
  {
    try {
      (arg1)->setVertexColourTracking(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_point_size

  call-seq:
    get_point_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_point_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Pass const *)arg1)->getPointSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_point_size

  call-seq:
    set_point_size(Real ps)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_point_size(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);
  {
    try {
      (arg1)->setPointSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_point_sprites_enabled

  call-seq:
    set_point_sprites_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_point_sprites_enabled(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);
  {
    try {
      (arg1)->setPointSpritesEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_point_sprites_enabled

  call-seq:
    get_point_sprites_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_point_sprites_enabled(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getPointSpritesEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_point_attenuation

  call-seq:
    set_point_attenuation(bool enabled, Real constant=0.0, Real linear=1.0, Real quadratic=0.0)
    set_point_attenuation(bool enabled, Real constant=0.0, Real linear=1.0)
    set_point_attenuation(bool enabled, Real constant=0.0)
    set_point_attenuation(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_point_attenuation__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);
  {
    try {
      (arg1)->setPointAttenuation(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_point_attenuation__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);
  {
    try {
      (arg1)->setPointAttenuation(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_point_attenuation__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);
  {
    try {
      (arg1)->setPointAttenuation(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_point_attenuation__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);
  {
    try {
      (arg1)->setPointAttenuation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_point_attenuation(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_set_point_attenuation__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_set_point_attenuation__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_set_point_attenuation__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_set_point_attenuation__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Pass.set_point_attenuation", 
    "    void Pass.set_point_attenuation(bool enabled, Ogre::Real constant, Ogre::Real linear, Ogre::Real quadratic)\n"
    "    void Pass.set_point_attenuation(bool enabled, Ogre::Real constant, Ogre::Real linear)\n"
    "    void Pass.set_point_attenuation(bool enabled, Ogre::Real constant)\n"
    "    void Pass.set_point_attenuation(bool enabled)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.is_point_attenuation_enabled

  call-seq:
    is_point_attenuation_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_is_point_attenuation_enabled(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->isPointAttenuationEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_point_attenuation_constant

  call-seq:
    get_point_attenuation_constant -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_point_attenuation_constant(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Pass const *)arg1)->getPointAttenuationConstant();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_point_attenuation_linear

  call-seq:
    get_point_attenuation_linear -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_point_attenuation_linear(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Pass const *)arg1)->getPointAttenuationLinear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_point_attenuation_quadratic

  call-seq:
    get_point_attenuation_quadratic -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_point_attenuation_quadratic(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Pass const *)arg1)->getPointAttenuationQuadratic();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_point_min_size

  call-seq:
    set_point_min_size(Real min)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_point_min_size(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);
  {
    try {
      (arg1)->setPointMinSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_point_min_size

  call-seq:
    get_point_min_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_point_min_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Pass const *)arg1)->getPointMinSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_point_max_size

  call-seq:
    set_point_max_size(Real max)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_point_max_size(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);
  {
    try {
      (arg1)->setPointMaxSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_point_max_size

  call-seq:
    get_point_max_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_point_max_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Pass const *)arg1)->getPointMaxSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_ambient

  call-seq:
    get_ambient -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_ambient(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::Pass const *)arg1)->getAmbient();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_diffuse

  call-seq:
    get_diffuse -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_diffuse(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::Pass const *)arg1)->getDiffuse();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_specular

  call-seq:
    get_specular -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_specular(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::Pass const *)arg1)->getSpecular();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_self_illumination

  call-seq:
    get_self_illumination -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_self_illumination(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::Pass const *)arg1)->getSelfIllumination();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_emissive

  call-seq:
    get_emissive -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_emissive(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::Pass const *)arg1)->getEmissive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shininess

  call-seq:
    get_shininess -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shininess(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Pass const *)arg1)->getShininess();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_vertex_colour_tracking

  call-seq:
    get_vertex_colour_tracking -> TrackVertexColourType

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_vertex_colour_tracking(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);
  {
    try {
      result = (Ogre::TrackVertexColourType)((Ogre::Pass const *)arg1)->getVertexColourTracking();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.create_texture_unit_state

  call-seq:
    create_texture_unit_state -> TextureUnitState
    create_texture_unit_state(String textureName, unsigned short texCoordSet=0) -> TextureUnitState
    create_texture_unit_state(String textureName) -> TextureUnitState

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_create_texture_unit_state__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);
  {
    try {
      result = (Ogre::TextureUnitState *)(arg1)->createTextureUnitState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_create_texture_unit_state__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);
  {
    try {
      result = (Ogre::TextureUnitState *)(arg1)->createTextureUnitState((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_texture_unit_state__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;
  }
  {
    try {
      result = (Ogre::TextureUnitState *)(arg1)->createTextureUnitState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_texture_unit_state(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_create_texture_unit_state__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_create_texture_unit_state__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_create_texture_unit_state__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.create_texture_unit_state", 
    "    Ogre::TextureUnitState * Pass.create_texture_unit_state()\n"
    "    Ogre::TextureUnitState * Pass.create_texture_unit_state(Ogre::String const &textureName, unsigned short texCoordSet)\n"
    "    Ogre::TextureUnitState * Pass.create_texture_unit_state(Ogre::String const &textureName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.add_texture_unit_state

  call-seq:
    add_texture_unit_state(TextureUnitState state)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_add_texture_unit_state(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);
  {
    try {
      (arg1)->addTextureUnitState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_texture_unit_state

  call-seq:
    get_texture_unit_state(unsigned short index) -> TextureUnitState
    get_texture_unit_state(String name) -> TextureUnitState
    get_texture_unit_state(unsigned short index) -> TextureUnitState
    get_texture_unit_state(String name) -> TextureUnitState

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_texture_unit_state__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);
  {
    try {
      result = (Ogre::TextureUnitState *)(arg1)->getTextureUnitState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_get_texture_unit_state__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;
  }
  {
    try {
      result = (Ogre::TextureUnitState *)(arg1)->getTextureUnitState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_texture_unit_state__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);
  {
    try {
      result = (Ogre::TextureUnitState *)((Ogre::Pass const *)arg1)->getTextureUnitState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_get_texture_unit_state__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;
  }
  {
    try {
      result = (Ogre::TextureUnitState *)((Ogre::Pass const *)arg1)->getTextureUnitState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_texture_unit_state(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_get_texture_unit_state__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_get_texture_unit_state__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_get_texture_unit_state__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_get_texture_unit_state__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Pass.get_texture_unit_state", 
    "    Ogre::TextureUnitState const * Pass.get_texture_unit_state(unsigned short index)\n"
    "    Ogre::TextureUnitState const * Pass.get_texture_unit_state(Ogre::String const &name)\n"
    "    Ogre::TextureUnitState const * Pass.get_texture_unit_state(unsigned short index)\n"
    "    Ogre::TextureUnitState const * Pass.get_texture_unit_state(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_texture_unit_state_index

  call-seq:
    get_texture_unit_state_index(TextureUnitState state) -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_texture_unit_state_index(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);
  {
    try {
      result = (unsigned short)((Ogre::Pass const *)arg1)->getTextureUnitStateIndex((Ogre::TextureUnitState const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_texture_unit_state_iterator

  call-seq:
    get_texture_unit_state_iterator -> TextureUnitStateIterator
    get_texture_unit_state_iterator -> ConstTextureUnitStateIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_texture_unit_state_iterator__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);
  {
    try {
      result = (arg1)->getTextureUnitStateIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_texture_unit_state_iterator__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);
  {
    try {
      result = ((Ogre::Pass const *)arg1)->getTextureUnitStateIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_texture_unit_state_iterator(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_get_texture_unit_state_iterator__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_get_texture_unit_state_iterator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Pass.get_texture_unit_state_iterator", 
    "    Ogre::Pass::ConstTextureUnitStateIterator Pass.get_texture_unit_state_iterator()\n"
    "    Ogre::Pass::ConstTextureUnitStateIterator Pass.get_texture_unit_state_iterator()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.remove_texture_unit_state

  call-seq:
    remove_texture_unit_state(unsigned short index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_remove_texture_unit_state(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);
  {
    try {
      (arg1)->removeTextureUnitState(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.remove_all_texture_unit_states

  call-seq:
    remove_all_texture_unit_states

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_remove_all_texture_unit_states(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);
  {
    try {
      (arg1)->removeAllTextureUnitStates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_num_texture_unit_states

  call-seq:
    get_num_texture_unit_states -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_num_texture_unit_states(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);
  {
    try {
      result = (unsigned short)((Ogre::Pass const *)arg1)->getNumTextureUnitStates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_scene_blending

  call-seq:
    set_scene_blending(SceneBlendType sbt)
    set_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_scene_blending__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);
  {
    try {
      (arg1)->setSceneBlending(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_separate_scene_blending

  call-seq:
    set_separate_scene_blending(SceneBlendType sbt, SceneBlendType sbta)
    set_separate_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, 
    SceneBlendFactor sourceFactorAlpha, 
    SceneBlendFactor destFactorAlpha)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_separate_scene_blending__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);
  {
    try {
      (arg1)->setSeparateSceneBlending(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_scene_blending

  call-seq:
    set_scene_blending(SceneBlendType sbt)
    set_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_scene_blending__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);
  {
    try {
      (arg1)->setSceneBlending(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_scene_blending(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_set_scene_blending__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_set_scene_blending__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.set_scene_blending", 
    "    void Pass.set_scene_blending(Ogre::SceneBlendType const sbt)\n"
    "    void Pass.set_scene_blending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_separate_scene_blending

  call-seq:
    set_separate_scene_blending(SceneBlendType sbt, SceneBlendType sbta)
    set_separate_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, 
    SceneBlendFactor sourceFactorAlpha, 
    SceneBlendFactor destFactorAlpha)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_separate_scene_blending__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);
  {
    try {
      (arg1)->setSeparateSceneBlending(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_separate_scene_blending(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_set_separate_scene_blending__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_set_separate_scene_blending__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Pass.set_separate_scene_blending", 
    "    void Pass.set_separate_scene_blending(Ogre::SceneBlendType const sbt, Ogre::SceneBlendType const sbta)\n"
    "    void Pass.set_separate_scene_blending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor, Ogre::SceneBlendFactor const sourceFactorAlpha, Ogre::SceneBlendFactor const destFactorAlpha)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.has_separate_scene_blending

  call-seq:
    has_separate_scene_blending -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_has_separate_scene_blending(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->hasSeparateSceneBlending();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_source_blend_factor

  call-seq:
    get_source_blend_factor -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_source_blend_factor(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);
  {
    try {
      result = (Ogre::SceneBlendFactor)((Ogre::Pass const *)arg1)->getSourceBlendFactor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_dest_blend_factor

  call-seq:
    get_dest_blend_factor -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_dest_blend_factor(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);
  {
    try {
      result = (Ogre::SceneBlendFactor)((Ogre::Pass const *)arg1)->getDestBlendFactor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_source_blend_factor_alpha

  call-seq:
    get_source_blend_factor_alpha -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_source_blend_factor_alpha(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);
  {
    try {
      result = (Ogre::SceneBlendFactor)((Ogre::Pass const *)arg1)->getSourceBlendFactorAlpha();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_dest_blend_factor_alpha

  call-seq:
    get_dest_blend_factor_alpha -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_dest_blend_factor_alpha(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);
  {
    try {
      result = (Ogre::SceneBlendFactor)((Ogre::Pass const *)arg1)->getDestBlendFactorAlpha();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_scene_blending_operation

  call-seq:
    set_scene_blending_operation(SceneBlendOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_scene_blending_operation(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);
  {
    try {
      (arg1)->setSceneBlendingOperation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_separate_scene_blending_operation

  call-seq:
    set_separate_scene_blending_operation(SceneBlendOperation op, SceneBlendOperation alphaOp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_separate_scene_blending_operation(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);
  {
    try {
      (arg1)->setSeparateSceneBlendingOperation(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.has_separate_scene_blending_operations

  call-seq:
    has_separate_scene_blending_operations -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_has_separate_scene_blending_operations(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->hasSeparateSceneBlendingOperations();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_scene_blending_operation

  call-seq:
    get_scene_blending_operation -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_scene_blending_operation(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);
  {
    try {
      result = (Ogre::SceneBlendOperation)((Ogre::Pass const *)arg1)->getSceneBlendingOperation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_scene_blending_operation_alpha

  call-seq:
    get_scene_blending_operation_alpha -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_scene_blending_operation_alpha(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);
  {
    try {
      result = (Ogre::SceneBlendOperation)((Ogre::Pass const *)arg1)->getSceneBlendingOperationAlpha();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.is_transparent

  call-seq:
    is_transparent -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_is_transparent(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->isTransparent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_depth_check_enabled

  call-seq:
    set_depth_check_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_depth_check_enabled(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);
  {
    try {
      (arg1)->setDepthCheckEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_depth_check_enabled

  call-seq:
    get_depth_check_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_depth_check_enabled(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getDepthCheckEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_depth_write_enabled

  call-seq:
    set_depth_write_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_depth_write_enabled(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);
  {
    try {
      (arg1)->setDepthWriteEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_depth_write_enabled

  call-seq:
    get_depth_write_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_depth_write_enabled(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getDepthWriteEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_depth_function

  call-seq:
    set_depth_function(CompareFunction func)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_depth_function(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);
  {
    try {
      (arg1)->setDepthFunction(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_depth_function

  call-seq:
    get_depth_function -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_depth_function(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);
  {
    try {
      result = (Ogre::CompareFunction)((Ogre::Pass const *)arg1)->getDepthFunction();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_colour_write_enabled

  call-seq:
    set_colour_write_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_colour_write_enabled(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);
  {
    try {
      (arg1)->setColourWriteEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_colour_write_enabled

  call-seq:
    get_colour_write_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_colour_write_enabled(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getColourWriteEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_culling_mode

  call-seq:
    set_culling_mode(CullingMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_culling_mode(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);
  {
    try {
      (arg1)->setCullingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_culling_mode

  call-seq:
    get_culling_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_culling_mode(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);
  {
    try {
      result = (Ogre::CullingMode)((Ogre::Pass const *)arg1)->getCullingMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_manual_culling_mode

  call-seq:
    set_manual_culling_mode(ManualCullingMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_manual_culling_mode(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);
  {
    try {
      (arg1)->setManualCullingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_manual_culling_mode

  call-seq:
    get_manual_culling_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_manual_culling_mode(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);
  {
    try {
      result = (Ogre::ManualCullingMode)((Ogre::Pass const *)arg1)->getManualCullingMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_lighting_enabled

  call-seq:
    set_lighting_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_lighting_enabled(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);
  {
    try {
      (arg1)->setLightingEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_lighting_enabled

  call-seq:
    get_lighting_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_lighting_enabled(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getLightingEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_max_simultaneous_lights

  call-seq:
    set_max_simultaneous_lights(unsigned short maxLights)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_max_simultaneous_lights(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);
  {
    try {
      (arg1)->setMaxSimultaneousLights(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_max_simultaneous_lights

  call-seq:
    get_max_simultaneous_lights -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_max_simultaneous_lights(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);
  {
    try {
      result = (unsigned short)((Ogre::Pass const *)arg1)->getMaxSimultaneousLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_start_light

  call-seq:
    set_start_light(unsigned short startLight)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_start_light(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);
  {
    try {
      (arg1)->setStartLight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_start_light

  call-seq:
    get_start_light -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_start_light(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);
  {
    try {
      result = (unsigned short)((Ogre::Pass const *)arg1)->getStartLight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_light_mask

  call-seq:
    set_light_mask(uint32 mask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_light_mask(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);
  {
    try {
      (arg1)->setLightMask(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_light_mask

  call-seq:
    get_light_mask -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_light_mask(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::Pass const *)arg1)->getLightMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_shading_mode

  call-seq:
    set_shading_mode(ShadeOptions mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_shading_mode(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);
  {
    try {
      (arg1)->setShadingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shading_mode

  call-seq:
    get_shading_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shading_mode(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);
  {
    try {
      result = (Ogre::ShadeOptions)((Ogre::Pass const *)arg1)->getShadingMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_polygon_mode

  call-seq:
    set_polygon_mode(PolygonMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_polygon_mode(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);
  {
    try {
      (arg1)->setPolygonMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_polygon_mode

  call-seq:
    get_polygon_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_polygon_mode(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);
  {
    try {
      result = (Ogre::PolygonMode)((Ogre::Pass const *)arg1)->getPolygonMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_polygon_mode_overrideable

  call-seq:
    set_polygon_mode_overrideable(bool override)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_polygon_mode_overrideable(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);
  {
    try {
      (arg1)->setPolygonModeOverrideable(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_polygon_mode_overrideable

  call-seq:
    get_polygon_mode_overrideable -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_polygon_mode_overrideable(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getPolygonModeOverrideable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_fog

  call-seq:
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White, 
    Real expDensity=0.001, Real linearStart=0.0, 
    Real linearEnd=1.0)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White, 
    Real expDensity=0.001, Real linearStart=0.0)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White, 
    Real expDensity=0.001)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE)
    set_fog(bool overrideScene)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_fog(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_set_fog__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_set_fog__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_set_fog__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_set_fog__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_set_fog__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_set_fog__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Pass.set_fog", 
    "    void Pass.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart, Ogre::Real linearEnd)\n"
    "    void Pass.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart)\n"
    "    void Pass.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity)\n"
    "    void Pass.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour)\n"
    "    void Pass.set_fog(bool overrideScene, Ogre::FogMode mode)\n"
    "    void Pass.set_fog(bool overrideScene)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_fog_override

  call-seq:
    get_fog_override -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_fog_override(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getFogOverride();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_fog_mode

  call-seq:
    get_fog_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_fog_mode(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);
  {
    try {
      result = (Ogre::FogMode)((Ogre::Pass const *)arg1)->getFogMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_fog_colour

  call-seq:
    get_fog_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_fog_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::Pass const *)arg1)->getFogColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_fog_start

  call-seq:
    get_fog_start -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_fog_start(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Pass const *)arg1)->getFogStart();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_fog_end

  call-seq:
    get_fog_end -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_fog_end(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Pass const *)arg1)->getFogEnd();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_fog_density

  call-seq:
    get_fog_density -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_fog_density(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Pass const *)arg1)->getFogDensity();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_depth_bias

  call-seq:
    set_depth_bias(float constantBias, float slopeScaleBias=0.0)
    set_depth_bias(float constantBias)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_depth_bias__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);
  {
    try {
      (arg1)->setDepthBias(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_depth_bias__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);
  {
    try {
      (arg1)->setDepthBias(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_depth_bias(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_set_depth_bias__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_set_depth_bias__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.set_depth_bias", 
    "    void Pass.set_depth_bias(float constantBias, float slopeScaleBias)\n"
    "    void Pass.set_depth_bias(float constantBias)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_depth_bias_constant

  call-seq:
    get_depth_bias_constant -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_depth_bias_constant(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);
  {
    try {
      result = (float)((Ogre::Pass const *)arg1)->getDepthBiasConstant();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_depth_bias_slope_scale

  call-seq:
    get_depth_bias_slope_scale -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_depth_bias_slope_scale(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);
  {
    try {
      result = (float)((Ogre::Pass const *)arg1)->getDepthBiasSlopeScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_iteration_depth_bias

  call-seq:
    set_iteration_depth_bias(float biasPerIteration)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_iteration_depth_bias(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);
  {
    try {
      (arg1)->setIterationDepthBias(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_iteration_depth_bias

  call-seq:
    get_iteration_depth_bias -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_iteration_depth_bias(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);
  {
    try {
      result = (float)((Ogre::Pass const *)arg1)->getIterationDepthBias();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_alpha_reject_settings

  call-seq:
    set_alpha_reject_settings(CompareFunction func, unsigned char value, bool alphaToCoverageEnabled=false)
    set_alpha_reject_settings(CompareFunction func, unsigned char value)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_alpha_reject_settings__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);
  {
    try {
      (arg1)->setAlphaRejectSettings(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_alpha_reject_settings__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);
  {
    try {
      (arg1)->setAlphaRejectSettings(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_alpha_reject_settings(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_set_alpha_reject_settings__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_set_alpha_reject_settings__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Pass.set_alpha_reject_settings", 
    "    void Pass.set_alpha_reject_settings(Ogre::CompareFunction func, unsigned char value, bool alphaToCoverageEnabled)\n"
    "    void Pass.set_alpha_reject_settings(Ogre::CompareFunction func, unsigned char value)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_alpha_reject_function

  call-seq:
    set_alpha_reject_function(CompareFunction func)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_alpha_reject_function(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);
  {
    try {
      (arg1)->setAlphaRejectFunction(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_alpha_reject_value

  call-seq:
    set_alpha_reject_value(unsigned char val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_alpha_reject_value(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);
  {
    try {
      (arg1)->setAlphaRejectValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_alpha_reject_function

  call-seq:
    get_alpha_reject_function -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_alpha_reject_function(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);
  {
    try {
      result = (Ogre::CompareFunction)((Ogre::Pass const *)arg1)->getAlphaRejectFunction();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_alpha_reject_value

  call-seq:
    get_alpha_reject_value -> unsigned char

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_alpha_reject_value(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);
  {
    try {
      result = (unsigned char)((Ogre::Pass const *)arg1)->getAlphaRejectValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_alpha_to_coverage_enabled

  call-seq:
    set_alpha_to_coverage_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_alpha_to_coverage_enabled(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);
  {
    try {
      (arg1)->setAlphaToCoverageEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.is_alpha_to_coverage_enabled

  call-seq:
    is_alpha_to_coverage_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_is_alpha_to_coverage_enabled(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->isAlphaToCoverageEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_transparent_sorting_enabled

  call-seq:
    set_transparent_sorting_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_transparent_sorting_enabled(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);
  {
    try {
      (arg1)->setTransparentSortingEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_transparent_sorting_enabled

  call-seq:
    get_transparent_sorting_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_transparent_sorting_enabled(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getTransparentSortingEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_transparent_sorting_forced

  call-seq:
    set_transparent_sorting_forced(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_transparent_sorting_forced(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);
  {
    try {
      (arg1)->setTransparentSortingForced(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_transparent_sorting_forced

  call-seq:
    get_transparent_sorting_forced -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_transparent_sorting_forced(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getTransparentSortingForced();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_iterate_per_light

  call-seq:
    set_iterate_per_light(bool enabled, bool onlyForOneLightType=true, LightTypes lightType=LT_POINT)
    set_iterate_per_light(bool enabled, bool onlyForOneLightType=true)
    set_iterate_per_light(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_iterate_per_light__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);
  {
    try {
      (arg1)->setIteratePerLight(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_iterate_per_light__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);
  {
    try {
      (arg1)->setIteratePerLight(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_iterate_per_light__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);
  {
    try {
      (arg1)->setIteratePerLight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_iterate_per_light(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_set_iterate_per_light__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_set_iterate_per_light__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_set_iterate_per_light__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Pass.set_iterate_per_light", 
    "    void Pass.set_iterate_per_light(bool enabled, bool onlyForOneLightType, Ogre::Light::LightTypes lightType)\n"
    "    void Pass.set_iterate_per_light(bool enabled, bool onlyForOneLightType)\n"
    "    void Pass.set_iterate_per_light(bool enabled)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_iterate_per_light

  call-seq:
    get_iterate_per_light -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_iterate_per_light(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getIteratePerLight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_run_only_for_one_light_type

  call-seq:
    get_run_only_for_one_light_type -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_run_only_for_one_light_type(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getRunOnlyForOneLightType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_only_light_type

  call-seq:
    get_only_light_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_only_light_type(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);
  {
    try {
      result = (Ogre::Light::LightTypes)((Ogre::Pass const *)arg1)->getOnlyLightType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_light_count_per_iteration

  call-seq:
    set_light_count_per_iteration(unsigned short c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_light_count_per_iteration(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);
  {
    try {
      (arg1)->setLightCountPerIteration(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_light_count_per_iteration

  call-seq:
    get_light_count_per_iteration -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_light_count_per_iteration(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);
  {
    try {
      result = (unsigned short)((Ogre::Pass const *)arg1)->getLightCountPerIteration();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_parent

  call-seq:
    get_parent -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_parent(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);
  {
    try {
      result = (Ogre::Technique *)((Ogre::Pass const *)arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_resource_group

  call-seq:
    get_resource_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_resource_group(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getResourceGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_vertex_program

  call-seq:
    set_vertex_program(String name, bool resetParams=true)
    set_vertex_program(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_vertex_program__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);
  {
    try {
      (arg1)->setVertexProgram((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_vertex_program__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;
  }
  {
    try {
      (arg1)->setVertexProgram((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_vertex_program(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_set_vertex_program__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_set_vertex_program__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.set_vertex_program", 
    "    void Pass.set_vertex_program(Ogre::String const &name, bool resetParams)\n"
    "    void Pass.set_vertex_program(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_vertex_program_parameters

  call-seq:
    set_vertex_program_parameters(GpuProgramParametersSharedPtr params)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_vertex_program_parameters(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));
    }
  }
  {
    try {
      (arg1)->setVertexProgramParameters(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_vertex_program_name

  call-seq:
    get_vertex_program_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_vertex_program_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getVertexProgramName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_vertex_program_parameters

  call-seq:
    get_vertex_program_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_vertex_program_parameters(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);
  {
    try {
      result = ((Ogre::Pass const *)arg1)->getVertexProgramParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_vertex_program

  call-seq:
    get_vertex_program -> GpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_vertex_program(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);
  {
    try {
      result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getVertexProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_shadow_caster_vertex_program

  call-seq:
    set_shadow_caster_vertex_program(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_shadow_caster_vertex_program(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;
  }
  {
    try {
      (arg1)->setShadowCasterVertexProgram((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_shadow_caster_vertex_program_parameters

  call-seq:
    set_shadow_caster_vertex_program_parameters(GpuProgramParametersSharedPtr params)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_shadow_caster_vertex_program_parameters(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));
    }
  }
  {
    try {
      (arg1)->setShadowCasterVertexProgramParameters(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shadow_caster_vertex_program_name

  call-seq:
    get_shadow_caster_vertex_program_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shadow_caster_vertex_program_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getShadowCasterVertexProgramName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shadow_caster_vertex_program_parameters

  call-seq:
    get_shadow_caster_vertex_program_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shadow_caster_vertex_program_parameters(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);
  {
    try {
      result = ((Ogre::Pass const *)arg1)->getShadowCasterVertexProgramParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shadow_caster_vertex_program

  call-seq:
    get_shadow_caster_vertex_program -> GpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shadow_caster_vertex_program(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);
  {
    try {
      result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getShadowCasterVertexProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_shadow_caster_fragment_program

  call-seq:
    set_shadow_caster_fragment_program(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_shadow_caster_fragment_program(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;
  }
  {
    try {
      (arg1)->setShadowCasterFragmentProgram((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_shadow_caster_fragment_program_parameters

  call-seq:
    set_shadow_caster_fragment_program_parameters(GpuProgramParametersSharedPtr params)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_shadow_caster_fragment_program_parameters(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));
    }
  }
  {
    try {
      (arg1)->setShadowCasterFragmentProgramParameters(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shadow_caster_fragment_program_name

  call-seq:
    get_shadow_caster_fragment_program_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shadow_caster_fragment_program_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getShadowCasterFragmentProgramName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shadow_caster_fragment_program_parameters

  call-seq:
    get_shadow_caster_fragment_program_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shadow_caster_fragment_program_parameters(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);
  {
    try {
      result = ((Ogre::Pass const *)arg1)->getShadowCasterFragmentProgramParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shadow_caster_fragment_program

  call-seq:
    get_shadow_caster_fragment_program -> GpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shadow_caster_fragment_program(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);
  {
    try {
      result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getShadowCasterFragmentProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_shadow_receiver_vertex_program

  call-seq:
    set_shadow_receiver_vertex_program(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_shadow_receiver_vertex_program(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;
  }
  {
    try {
      (arg1)->setShadowReceiverVertexProgram((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_shadow_receiver_vertex_program_parameters

  call-seq:
    set_shadow_receiver_vertex_program_parameters(GpuProgramParametersSharedPtr params)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_shadow_receiver_vertex_program_parameters(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));
    }
  }
  {
    try {
      (arg1)->setShadowReceiverVertexProgramParameters(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_shadow_receiver_fragment_program

  call-seq:
    set_shadow_receiver_fragment_program(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_shadow_receiver_fragment_program(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;
  }
  {
    try {
      (arg1)->setShadowReceiverFragmentProgram((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_shadow_receiver_fragment_program_parameters

  call-seq:
    set_shadow_receiver_fragment_program_parameters(GpuProgramParametersSharedPtr params)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_shadow_receiver_fragment_program_parameters(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));
    }
  }
  {
    try {
      (arg1)->setShadowReceiverFragmentProgramParameters(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shadow_receiver_vertex_program_name

  call-seq:
    get_shadow_receiver_vertex_program_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shadow_receiver_vertex_program_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getShadowReceiverVertexProgramName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shadow_receiver_vertex_program_parameters

  call-seq:
    get_shadow_receiver_vertex_program_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shadow_receiver_vertex_program_parameters(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);
  {
    try {
      result = ((Ogre::Pass const *)arg1)->getShadowReceiverVertexProgramParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shadow_receiver_vertex_program

  call-seq:
    get_shadow_receiver_vertex_program -> GpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shadow_receiver_vertex_program(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);
  {
    try {
      result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getShadowReceiverVertexProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shadow_receiver_fragment_program_name

  call-seq:
    get_shadow_receiver_fragment_program_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shadow_receiver_fragment_program_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getShadowReceiverFragmentProgramName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shadow_receiver_fragment_program_parameters

  call-seq:
    get_shadow_receiver_fragment_program_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shadow_receiver_fragment_program_parameters(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);
  {
    try {
      result = ((Ogre::Pass const *)arg1)->getShadowReceiverFragmentProgramParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_shadow_receiver_fragment_program

  call-seq:
    get_shadow_receiver_fragment_program -> GpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_shadow_receiver_fragment_program(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);
  {
    try {
      result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getShadowReceiverFragmentProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_fragment_program

  call-seq:
    set_fragment_program(String name, bool resetParams=true)
    set_fragment_program(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_fragment_program__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);
  {
    try {
      (arg1)->setFragmentProgram((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_fragment_program__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;
  }
  {
    try {
      (arg1)->setFragmentProgram((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_fragment_program(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_set_fragment_program__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_set_fragment_program__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.set_fragment_program", 
    "    void Pass.set_fragment_program(Ogre::String const &name, bool resetParams)\n"
    "    void Pass.set_fragment_program(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_fragment_program_parameters

  call-seq:
    set_fragment_program_parameters(GpuProgramParametersSharedPtr params)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_fragment_program_parameters(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));
    }
  }
  {
    try {
      (arg1)->setFragmentProgramParameters(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_fragment_program_name

  call-seq:
    get_fragment_program_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_fragment_program_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getFragmentProgramName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_fragment_program_parameters

  call-seq:
    get_fragment_program_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_fragment_program_parameters(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);
  {
    try {
      result = ((Ogre::Pass const *)arg1)->getFragmentProgramParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_fragment_program

  call-seq:
    get_fragment_program -> GpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_fragment_program(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);
  {
    try {
      result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getFragmentProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_geometry_program

  call-seq:
    set_geometry_program(String name, bool resetParams=true)
    set_geometry_program(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_geometry_program__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);
  {
    try {
      (arg1)->setGeometryProgram((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_geometry_program__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;
  }
  {
    try {
      (arg1)->setGeometryProgram((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_geometry_program(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_set_geometry_program__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_set_geometry_program__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.set_geometry_program", 
    "    void Pass.set_geometry_program(Ogre::String const &name, bool resetParams)\n"
    "    void Pass.set_geometry_program(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_geometry_program_parameters

  call-seq:
    set_geometry_program_parameters(GpuProgramParametersSharedPtr params)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_geometry_program_parameters(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));
    }
  }
  {
    try {
      (arg1)->setGeometryProgramParameters(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_geometry_program_name

  call-seq:
    get_geometry_program_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_geometry_program_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getGeometryProgramName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_geometry_program_parameters

  call-seq:
    get_geometry_program_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_geometry_program_parameters(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);
  {
    try {
      result = ((Ogre::Pass const *)arg1)->getGeometryProgramParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_geometry_program

  call-seq:
    get_geometry_program -> GpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_geometry_program(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);
  {
    try {
      result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getGeometryProgram();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass._split

  call-seq:
    _split(unsigned short numUnits) -> Pass

An instance method.

*/
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);
  {
    try {
      result = (Ogre::Pass *)(arg1)->_split(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass._notify_index

  call-seq:
    _notify_index(unsigned short index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass__notify_index(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);
  {
    try {
      (arg1)->_notifyIndex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass._prepare

  call-seq:
    _prepare

An instance method.

*/
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);
  {
    try {
      (arg1)->_prepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass._unprepare

  call-seq:
    _unprepare

An instance method.

*/
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);
  {
    try {
      (arg1)->_unprepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass._load

  call-seq:
    _load

An instance method.

*/
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);
  {
    try {
      (arg1)->_load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass._unload

  call-seq:
    _unload

An instance method.

*/
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);
  {
    try {
      (arg1)->_unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.is_loaded

  call-seq:
    is_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_is_loaded(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->isLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_hash

  call-seq:
    get_hash -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_hash(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::Pass const *)arg1)->getHash();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass._dirty_hash

  call-seq:
    _dirty_hash

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass__dirty_hash(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);
  {
    try {
      (arg1)->_dirtyHash();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass._recalculate_hash

  call-seq:
    _recalculate_hash

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass__recalculate_hash(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);
  {
    try {
      (arg1)->_recalculateHash();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass._notify_needs_recompile

  call-seq:
    _notify_needs_recompile

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass__notify_needs_recompile(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);
  {
    try {
      (arg1)->_notifyNeedsRecompile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass._update_auto_params

  call-seq:
    _update_auto_params(AutoParamDataSource source, uint16 variabilityMask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass__update_auto_params(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);
  {
    try {
      ((Ogre::Pass const *)arg1)->_updateAutoParams((Ogre::AutoParamDataSource const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass._get_texture_unit_with_content_type_index

  call-seq:
    _get_texture_unit_with_content_type_index(ContentType contentType, unsigned short index) -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass__get_texture_unit_with_content_type_index(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);
  {
    try {
      result = (unsigned short)((Ogre::Pass const *)arg1)->_getTextureUnitWithContentTypeIndex(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_texture_filtering

  call-seq:
    set_texture_filtering(TextureFilterOptions filterType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_texture_filtering(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);
  {
    try {
      (arg1)->setTextureFiltering(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_texture_anisotropy

  call-seq:
    set_texture_anisotropy(unsigned int maxAniso)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_texture_anisotropy(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);
  {
    try {
      (arg1)->setTextureAnisotropy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_normalise_normals

  call-seq:
    set_normalise_normals(bool normalise)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_normalise_normals(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);
  {
    try {
      (arg1)->setNormaliseNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_normalise_normals

  call-seq:
    get_normalise_normals -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_normalise_normals(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getNormaliseNormals();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_dirty_hash_list

  call-seq:
    get_dirty_hash_list -> PassSet

A class method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_dirty_hash_list(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;
  }
  {
    try {
      result = (Ogre::Pass::PassSet *) &Ogre::Pass::getDirtyHashList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::Pass.get_pass_graveyard

  call-seq:
    get_pass_graveyard -> PassSet

A class method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_pass_graveyard(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;
  }
  {
    try {
      result = (Ogre::Pass::PassSet *) &Ogre::Pass::getPassGraveyard();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::Pass.clear_dirty_hash_list

  call-seq:
    clear_dirty_hash_list

A class method.

*/
SWIGINTERN VALUE
_wrap_Pass_clear_dirty_hash_list(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      Ogre::Pass::clearDirtyHashList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.process_pending_pass_updates

  call-seq:
    process_pending_pass_updates

A class method.

*/
SWIGINTERN VALUE
_wrap_Pass_process_pending_pass_updates(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      Ogre::Pass::processPendingPassUpdates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.queue_for_deletion

  call-seq:
    queue_for_deletion

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_queue_for_deletion(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);
  {
    try {
      (arg1)->queueForDeletion();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.is_ambient_only

  call-seq:
    is_ambient_only -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_is_ambient_only(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->isAmbientOnly();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_pass_iteration_count

  call-seq:
    set_pass_iteration_count(size_t count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_pass_iteration_count(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);
  {
    try {
      (arg1)->setPassIterationCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_pass_iteration_count

  call-seq:
    get_pass_iteration_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_pass_iteration_count(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);
  {
    try {
      result = ((Ogre::Pass const *)arg1)->getPassIterationCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.apply_texture_aliases

  call-seq:
    apply_texture_aliases(AliasTextureNamePairList aliasList, bool apply=true) -> bool
    apply_texture_aliases(AliasTextureNamePairList aliasList) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_apply_texture_aliases__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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_apply_texture_aliases__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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_apply_texture_aliases(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_apply_texture_aliases__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_apply_texture_aliases__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.apply_texture_aliases", 
    "    bool Pass.apply_texture_aliases(Ogre::AliasTextureNamePairList const &aliasList, bool const apply)\n"
    "    bool Pass.apply_texture_aliases(Ogre::AliasTextureNamePairList const &aliasList)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_light_scissoring_enabled

  call-seq:
    set_light_scissoring_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_light_scissoring_enabled(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);
  {
    try {
      (arg1)->setLightScissoringEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_light_scissoring_enabled

  call-seq:
    get_light_scissoring_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_light_scissoring_enabled(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getLightScissoringEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_light_clip_planes_enabled

  call-seq:
    set_light_clip_planes_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_light_clip_planes_enabled(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);
  {
    try {
      (arg1)->setLightClipPlanesEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_light_clip_planes_enabled

  call-seq:
    get_light_clip_planes_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_light_clip_planes_enabled(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);
  {
    try {
      result = (bool)((Ogre::Pass const *)arg1)->getLightClipPlanesEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.set_illumination_stage

  call-seq:
    set_illumination_stage(IlluminationStage is)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_illumination_stage(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);
  {
    try {
      (arg1)->setIlluminationStage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_illumination_stage

  call-seq:
    get_illumination_stage -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_illumination_stage(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);
  {
    try {
      result = (Ogre::IlluminationStage)((Ogre::Pass const *)arg1)->getIlluminationStage();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BuiltinHashFunction.MIN_TEXTURE_CHANGE

  call-seq:
    MIN_TEXTURE_CHANGE -> int

A class method.

*/

/*
  Document-method: Ogre::BuiltinHashFunction.MIN_GPU_PROGRAM_CHANGE

  call-seq:
    MIN_GPU_PROGRAM_CHANGE -> int

A class method.

*/

/*
  Document-method: Ogre::Pass.set_hash_function

  call-seq:
    set_hash_function(BuiltinHashFunction builtin)
    set_hash_function(HashFunc hashFunc)

A class method.

*/
SWIGINTERN VALUE
_wrap_Pass_set_hash_function__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);
  {
    try {
      Ogre::Pass::setHashFunction(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_set_hash_function__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);
  {
    try {
      Ogre::Pass::setHashFunction(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_set_hash_function(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_set_hash_function__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_set_hash_function__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Pass.set_hash_function", 
    "    void Pass.set_hash_function(Ogre::Pass::BuiltinHashFunction builtin)\n"
    "    void Pass.set_hash_function(Ogre::Pass::HashFunc *hashFunc)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_hash_function

  call-seq:
    get_hash_function -> HashFunc

A class method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_hash_function(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;
  }
  {
    try {
      result = (Ogre::Pass::HashFunc *)Ogre::Pass::getHashFunction();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass__HashFunc, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_builtin_hash_function

  call-seq:
    get_builtin_hash_function(BuiltinHashFunction builtin) -> HashFunc

A class method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_builtin_hash_function(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);
  {
    try {
      result = (Ogre::Pass::HashFunc *)Ogre::Pass::getBuiltinHashFunction(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass__HashFunc, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pass.get_user_object_bindings

  call-seq:
    get_user_object_bindings -> UserObjectBindings
    get_user_object_bindings -> UserObjectBindings

An instance method.

*/
SWIGINTERN VALUE
_wrap_Pass_get_user_object_bindings__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);
  {
    try {
      result = (Ogre::UserObjectBindings *) &(arg1)->getUserObjectBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_get_user_object_bindings__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);
  {
    try {
      result = (Ogre::UserObjectBindings *) &((Ogre::Pass const *)arg1)->getUserObjectBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_get_user_object_bindings(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_get_user_object_bindings__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_get_user_object_bindings__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Pass.get_user_object_bindings", 
    "    Ogre::UserObjectBindings const & Pass.get_user_object_bindings()\n"
    "    Ogre::UserObjectBindings const & Pass.get_user_object_bindings()\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::IlluminationPass

  Proxy of C++ Ogre::IlluminationPass class


*/
swig_class SwigClassIlluminationPass;


/*
  Document-method: Ogre::IlluminationPass.stage

  call-seq:
    stage -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::IlluminationPass.stage=

  call-seq:
    stage=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::IlluminationPass.pass

  call-seq:
    pass -> Pass

Get value of attribute.

*/

/*
  Document-method: Ogre::IlluminationPass.pass=

  call-seq:
    pass=(x) -> Pass

Set new value for attribute.

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



/*
  Document-method: Ogre::IlluminationPass.destroyOnShutdown

  call-seq:
    destroyOnShutdown -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::IlluminationPass.destroyOnShutdown=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::IlluminationPass.originalPass

  call-seq:
    originalPass -> Pass

Get value of attribute.

*/

/*
  Document-method: Ogre::IlluminationPass.originalPass=

  call-seq:
    originalPass=(x) -> Pass

Set new value for attribute.

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


/*
  Document-method: Ogre::IlluminationPass.new

  call-seq:
    IlluminationPass.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::IlluminationPass *)new Ogre::IlluminationPass();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_IlluminationPass(Ogre::IlluminationPass *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::PixelCountLodStrategy < Ogre::Ogre::LodStrategy

  Proxy of C++ Ogre::PixelCountLodStrategy class


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


/*
  Document-method: Ogre::PixelCountLodStrategy.new

  call-seq:
    PixelCountLodStrategy.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PixelCountLodStrategy *)new Ogre::PixelCountLodStrategy();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelCountLodStrategy.get_base_value

  call-seq:
    get_base_value -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_get_base_value(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);
  {
    try {
      result = (Ogre::Real)((Ogre::PixelCountLodStrategy const *)arg1)->getBaseValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelCountLodStrategy.transform_bias

  call-seq:
    transform_bias(Real factor) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_transform_bias(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);
  {
    try {
      result = (Ogre::Real)((Ogre::PixelCountLodStrategy const *)arg1)->transformBias(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelCountLodStrategy.get_index

  call-seq:
    get_index(Real value, MeshLodUsageList meshLodUsageList) -> ushort
    get_index(Real value, LodValueList materialLodValueList) -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_get_index__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);
  {
    try {
      result = (Ogre::ushort)((Ogre::PixelCountLodStrategy const *)arg1)->getIndex(arg2,(Ogre::Mesh::MeshLodUsageList const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_get_index__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);
  {
    try {
      result = (Ogre::ushort)((Ogre::PixelCountLodStrategy const *)arg1)->getIndex(arg2,(Ogre::Material::LodValueList const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PixelCountLodStrategy_get_index(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_get_index__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_get_index__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "PixelCountLodStrategy.get_index", 
    "    Ogre::ushort PixelCountLodStrategy.get_index(Ogre::Real value, Ogre::Mesh::MeshLodUsageList const &meshLodUsageList)\n"
    "    Ogre::ushort PixelCountLodStrategy.get_index(Ogre::Real value, Ogre::Material::LodValueList const &materialLodValueList)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PixelCountLodStrategy.sort

  call-seq:
    sort(MeshLodUsageList meshLodUsageList)

An instance method.

*/
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);
  {
    try {
      ((Ogre::PixelCountLodStrategy const *)arg1)->sort(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelCountLodStrategy.is_sorted

  call-seq:
    is_sorted(LodValueList values) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_is_sorted(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);
  {
    try {
      result = (bool)((Ogre::PixelCountLodStrategy const *)arg1)->isSorted((Ogre::Mesh::LodValueList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelCountLodStrategy.get_singleton

  call-seq:
    get_singleton -> PixelCountLodStrategy

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_get_singleton(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;
  }
  {
    try {
      result = (Ogre::PixelCountLodStrategy *) &Ogre::PixelCountLodStrategy::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PixelCountLodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PixelCountLodStrategy.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> PixelCountLodStrategy

A class method.

*/
SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::PixelCountLodStrategy *)Ogre::PixelCountLodStrategy::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PixelCountLodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PixelCountLodStrategy(Ogre::PixelCountLodStrategy *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::PlatformInformation

  Proxy of C++ Ogre::PlatformInformation class


*/
swig_class SwigClassPlatformInformation;


/*
  Document-method: Ogre::CpuFeatures.CPU_FEATURE_NONE

  call-seq:
    CPU_FEATURE_NONE -> int

A class method.

*/

/*
  Document-method: Ogre::PlatformInformation.get_cpu_identifier

  call-seq:
    get_cpu_identifier -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_PlatformInformation_get_cpu_identifier(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::PlatformInformation::getCpuIdentifier();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PlatformInformation.get_cpu_features

  call-seq:
    get_cpu_features -> uint

A class method.

*/
SWIGINTERN VALUE
_wrap_PlatformInformation_get_cpu_features(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;
  }
  {
    try {
      result = (Ogre::uint)Ogre::PlatformInformation::getCpuFeatures();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PlatformInformation.has_cpu_feature

  call-seq:
    has_cpu_feature(CpuFeatures feature) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_PlatformInformation_has_cpu_feature(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);
  {
    try {
      result = (bool)Ogre::PlatformInformation::hasCpuFeature(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PlatformInformation.log

  call-seq:
    log(Log pLog)

A class method.

*/
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);
  {
    try {
      Ogre::PlatformInformation::log(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::PlatformInformation.new

  call-seq:
    PlatformInformation.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PlatformInformation *)new Ogre::PlatformInformation();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PlatformInformation(Ogre::PlatformInformation *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::Plugin

  Proxy of C++ Ogre::Plugin class


*/
swig_class SwigClassPlugin;

SWIGINTERN void
free_Ogre_Plugin(Ogre::Plugin *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Plugin.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Plugin_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Plugin const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Plugin.install

  call-seq:
    install

An instance method.

*/
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);
  {
    try {
      (arg1)->install();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Plugin.initialise

  call-seq:
    initialise

An instance method.

*/
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);
  {
    try {
      (arg1)->initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Plugin.shutdown

  call-seq:
    shutdown

An instance method.

*/
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);
  {
    try {
      (arg1)->shutdown();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Plugin.uninstall

  call-seq:
    uninstall

An instance method.

*/
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);
  {
    try {
      (arg1)->uninstall();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PrefabFactory

  Proxy of C++ Ogre::PrefabFactory class


*/
swig_class SwigClassPrefabFactory;


/*
  Document-method: Ogre::PrefabFactory.create_prefab

  call-seq:
    create_prefab(Mesh mesh) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_PrefabFactory_create_prefab(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);
  {
    try {
      result = (bool)Ogre::PrefabFactory::createPrefab(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
  }
  


/*
  Document-method: Ogre::PrefabFactory.new

  call-seq:
    PrefabFactory.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PrefabFactory *)new Ogre::PrefabFactory();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PrefabFactory(Ogre::PrefabFactory *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::Profile

  Proxy of C++ Ogre::Profile class


*/
swig_class SwigClassProfile;


/*
  Document-method: Ogre::Profile.new

  call-seq:
    Profile.new(String profileName, uint32 groupID=(uint32) Ogre::OGREPROF_USER_DEFAULT)
    Profile.new(String profileName)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Profile *)new Ogre::Profile((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Profile *)new Ogre::Profile((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::Profiler

  Proxy of C++ Ogre::Profiler class


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


/*
  Document-method: Ogre::Profiler.new

  call-seq:
    Profiler.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Profiler *)new Ogre::Profiler();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Profiler(Ogre::Profiler *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Profiler.set_timer

  call-seq:
    set_timer(Timer t)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_set_timer(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);
  {
    try {
      (arg1)->setTimer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.get_timer

  call-seq:
    get_timer -> Timer

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_get_timer(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);
  {
    try {
      result = (Ogre::Timer *)(arg1)->getTimer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Timer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.begin_profile

  call-seq:
    begin_profile(String profileName, uint32 groupID=(uint32) Ogre::OGREPROF_USER_DEFAULT)
    begin_profile(String profileName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_begin_profile__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);
  {
    try {
      (arg1)->beginProfile((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_begin_profile__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;
  }
  {
    try {
      (arg1)->beginProfile((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Profiler_begin_profile(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_begin_profile__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_begin_profile__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Profiler.begin_profile", 
    "    void Profiler.begin_profile(Ogre::String const &profileName, Ogre::uint32 groupID)\n"
    "    void Profiler.begin_profile(Ogre::String const &profileName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.end_profile

  call-seq:
    end_profile(String profileName, uint32 groupID=(uint32) Ogre::OGREPROF_USER_DEFAULT)
    end_profile(String profileName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_end_profile__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);
  {
    try {
      (arg1)->endProfile((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_end_profile__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;
  }
  {
    try {
      (arg1)->endProfile((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Profiler_end_profile(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_end_profile__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_end_profile__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Profiler.end_profile", 
    "    void Profiler.end_profile(Ogre::String const &profileName, Ogre::uint32 groupID)\n"
    "    void Profiler.end_profile(Ogre::String const &profileName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.begin_gpuevent

  call-seq:
    begin_gpuevent(String event)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_begin_gpuevent(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 *","beginGPUEvent", 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 &","beginGPUEvent", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","beginGPUEvent", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->beginGPUEvent((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.end_gpuevent

  call-seq:
    end_gpuevent(String event)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_end_gpuevent(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 *","endGPUEvent", 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 &","endGPUEvent", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","endGPUEvent", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->endGPUEvent((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.mark_gpuevent

  call-seq:
    mark_gpuevent(String event)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_mark_gpuevent(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 *","markGPUEvent", 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 &","markGPUEvent", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","markGPUEvent", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->markGPUEvent((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.set_enabled

  call-seq:
    set_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_set_enabled(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);
  {
    try {
      (arg1)->setEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.get_enabled

  call-seq:
    get_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_get_enabled(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);
  {
    try {
      result = (bool)((Ogre::Profiler const *)arg1)->getEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.enable_profile

  call-seq:
    enable_profile(String profileName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_enable_profile(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;
  }
  {
    try {
      (arg1)->enableProfile((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.disable_profile

  call-seq:
    disable_profile(String profileName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_disable_profile(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;
  }
  {
    try {
      (arg1)->disableProfile((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.set_profile_group_mask

  call-seq:
    set_profile_group_mask(uint32 mask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_set_profile_group_mask(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);
  {
    try {
      (arg1)->setProfileGroupMask(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.get_profile_group_mask

  call-seq:
    get_profile_group_mask -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_get_profile_group_mask(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::Profiler const *)arg1)->getProfileGroupMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.watch_for_max

  call-seq:
    watch_for_max(String profileName) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_watch_for_max(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;
  }
  {
    try {
      result = (bool)(arg1)->watchForMax((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.watch_for_min

  call-seq:
    watch_for_min(String profileName) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_watch_for_min(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;
  }
  {
    try {
      result = (bool)(arg1)->watchForMin((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.watch_for_limit

  call-seq:
    watch_for_limit(String profileName, Real limit, bool greaterThan=true) -> bool
    watch_for_limit(String profileName, Real limit) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_watch_for_limit__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);
  {
    try {
      result = (bool)(arg1)->watchForLimit((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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_watch_for_limit__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);
  {
    try {
      result = (bool)(arg1)->watchForLimit((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_watch_for_limit(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_watch_for_limit__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_watch_for_limit__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Profiler.watch_for_limit", 
    "    bool Profiler.watch_for_limit(Ogre::String const &profileName, Ogre::Real limit, bool greaterThan)\n"
    "    bool Profiler.watch_for_limit(Ogre::String const &profileName, Ogre::Real limit)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.log_results

  call-seq:
    log_results

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_log_results(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);
  {
    try {
      (arg1)->logResults();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.reset

  call-seq:
    reset

An instance method.

*/
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);
  {
    try {
      (arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DisplayMode.DISPLAY_PERCENTAGE

  call-seq:
    DISPLAY_PERCENTAGE -> int

A class method.

*/

/*
  Document-method: Ogre::DisplayMode.DISPLAY_MILLISECONDS

  call-seq:
    DISPLAY_MILLISECONDS -> int

A class method.

*/

/*
  Document-method: Ogre::Profiler.set_display_mode

  call-seq:
    set_display_mode(DisplayMode d)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_set_display_mode(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);
  {
    try {
      (arg1)->setDisplayMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.get_display_mode

  call-seq:
    get_display_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_get_display_mode(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);
  {
    try {
      result = (Ogre::Profiler::DisplayMode)((Ogre::Profiler const *)arg1)->getDisplayMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.set_update_display_frequency

  call-seq:
    set_update_display_frequency(uint freq)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_set_update_display_frequency(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);
  {
    try {
      (arg1)->setUpdateDisplayFrequency(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.get_update_display_frequency

  call-seq:
    get_update_display_frequency -> uint

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_get_update_display_frequency(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);
  {
    try {
      result = (Ogre::uint)((Ogre::Profiler const *)arg1)->getUpdateDisplayFrequency();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.set_overlay_dimensions

  call-seq:
    set_overlay_dimensions(Real width, Real height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_set_overlay_dimensions(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);
  {
    try {
      (arg1)->setOverlayDimensions(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.set_overlay_position

  call-seq:
    set_overlay_position(Real left, Real top)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_set_overlay_position(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);
  {
    try {
      (arg1)->setOverlayPosition(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.get_overlay_width

  call-seq:
    get_overlay_width -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_get_overlay_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Profiler const *)arg1)->getOverlayWidth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.get_overlay_height

  call-seq:
    get_overlay_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_get_overlay_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Profiler const *)arg1)->getOverlayHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.get_overlay_left

  call-seq:
    get_overlay_left -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_get_overlay_left(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Profiler const *)arg1)->getOverlayLeft();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.get_overlay_top

  call-seq:
    get_overlay_top -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Profiler_get_overlay_top(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Profiler const *)arg1)->getOverlayTop();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.get_singleton

  call-seq:
    get_singleton -> Profiler

A class method.

*/
SWIGINTERN VALUE
_wrap_Profiler_get_singleton(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;
  }
  {
    try {
      result = (Ogre::Profiler *) &Ogre::Profiler::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Profiler, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Profiler.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> Profiler

A class method.

*/
SWIGINTERN VALUE
_wrap_Profiler_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::Profiler *)Ogre::Profiler::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Profiler, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RenderObjectListener

  Proxy of C++ Ogre::RenderObjectListener class


*/
swig_class SwigClassRenderObjectListener;

SWIGINTERN void
free_Ogre_RenderObjectListener(Ogre::RenderObjectListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderObjectListener.notify_render_single_object

  call-seq:
    notify_render_single_object(Renderable rend, Pass pass, AutoParamDataSource source, 
    LightList pLightList, bool suppressRenderStateChanges)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderObjectListener_notify_render_single_object(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 {
    {
      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(Ogre::Exception& e) {
        static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
        rb_raise(cpperror, "%s", e.getFullDescription().c_str());
      }
    }
  } 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;
  }
  


/*
  Document-method: Ogre::RenderObjectListener.new

  call-seq:
    RenderObjectListener.new

Class constructor.

*/
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;
  {
    try {
      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;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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;
}



/*
  Document-class: Ogre::Technique

  Proxy of C++ Ogre::Technique class


*/
swig_class SwigClassTechnique;


/*
  Document-method: Ogre::IncludeOrExclude.INCLUDE

  call-seq:
    INCLUDE -> int

A class method.

*/

/*
  Document-method: Ogre::IncludeOrExclude.EXCLUDE

  call-seq:
    EXCLUDE -> int

A class method.

*/

/*
  Document-method: Ogre::Technique.new

  call-seq:
    Technique.new(Material parent)
    Technique.new(Material parent, Technique oth)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Technique *)new Ogre::Technique(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::Technique *)new Ogre::Technique(arg1,(Ogre::Technique const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::Technique.is_supported

  call-seq:
    is_supported -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_is_supported(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);
  {
    try {
      result = (bool)((Ogre::Technique const *)arg1)->isSupported();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique._compile

  call-seq:
    _compile(bool autoManageTextureUnits) -> String

An instance method.

*/
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);
  {
    try {
      result = (arg1)->_compile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.check_gpurules

  call-seq:
    check_gpurules(StrStreamType errors) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_check_gpurules(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);
  {
    try {
      result = (bool)(arg1)->checkGPURules(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.check_hardware_support

  call-seq:
    check_hardware_support(bool autoManageTextureUnits, StrStreamType compileErrors) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_check_hardware_support(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);
  {
    try {
      result = (bool)(arg1)->checkHardwareSupport(arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique._compile_illumination_passes

  call-seq:
    _compile_illumination_passes

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique__compile_illumination_passes(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);
  {
    try {
      (arg1)->_compileIlluminationPasses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.create_pass

  call-seq:
    create_pass -> Pass

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_create_pass(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);
  {
    try {
      result = (Ogre::Pass *)(arg1)->createPass();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.get_pass

  call-seq:
    get_pass(unsigned short index) -> Pass
    get_pass(String name) -> Pass

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_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 ;
  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);
  {
    try {
      result = (Ogre::Pass *)(arg1)->getPass(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_get_pass__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;
  }
  {
    try {
      result = (Ogre::Pass *)(arg1)->getPass((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_pass(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_get_pass__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_get_pass__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Technique.get_pass", 
    "    Ogre::Pass * Technique.get_pass(unsigned short index)\n"
    "    Ogre::Pass * Technique.get_pass(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.get_num_passes

  call-seq:
    get_num_passes -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_num_passes(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);
  {
    try {
      result = (unsigned short)((Ogre::Technique const *)arg1)->getNumPasses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.remove_pass

  call-seq:
    remove_pass(unsigned short index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_remove_pass(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);
  {
    try {
      (arg1)->removePass(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.remove_all_passes

  call-seq:
    remove_all_passes

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_remove_all_passes(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);
  {
    try {
      (arg1)->removeAllPasses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.move_pass

  call-seq:
    move_pass(unsigned short sourceIndex, unsigned short destinationIndex) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_move_pass(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);
  {
    try {
      result = (bool)(arg1)->movePass(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.get_pass_iterator

  call-seq:
    get_pass_iterator -> PassIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_pass_iterator(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);
  {
    try {
      result = (arg1)->getPassIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Technique.get_illumination_pass_iterator

  call-seq:
    get_illumination_pass_iterator -> IlluminationPassIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_illumination_pass_iterator(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);
  {
    try {
      result = (arg1)->getIlluminationPassIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Technique.get_parent

  call-seq:
    get_parent -> Material

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_parent(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);
  {
    try {
      result = (Ogre::Material *)((Ogre::Technique const *)arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.get_resource_group

  call-seq:
    get_resource_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_resource_group(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Technique const *)arg1)->getResourceGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.is_transparent

  call-seq:
    is_transparent -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_is_transparent(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);
  {
    try {
      result = (bool)((Ogre::Technique const *)arg1)->isTransparent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.is_transparent_sorting_enabled

  call-seq:
    is_transparent_sorting_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_is_transparent_sorting_enabled(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);
  {
    try {
      result = (bool)((Ogre::Technique const *)arg1)->isTransparentSortingEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.is_transparent_sorting_forced

  call-seq:
    is_transparent_sorting_forced -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_is_transparent_sorting_forced(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);
  {
    try {
      result = (bool)((Ogre::Technique const *)arg1)->isTransparentSortingForced();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique._prepare

  call-seq:
    _prepare

An instance method.

*/
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);
  {
    try {
      (arg1)->_prepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique._unprepare

  call-seq:
    _unprepare

An instance method.

*/
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);
  {
    try {
      (arg1)->_unprepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique._load

  call-seq:
    _load

An instance method.

*/
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);
  {
    try {
      (arg1)->_load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique._unload

  call-seq:
    _unload

An instance method.

*/
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);
  {
    try {
      (arg1)->_unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.is_loaded

  call-seq:
    is_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_is_loaded(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);
  {
    try {
      result = (bool)((Ogre::Technique const *)arg1)->isLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique._notify_needs_recompile

  call-seq:
    _notify_needs_recompile

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique__notify_needs_recompile(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);
  {
    try {
      (arg1)->_notifyNeedsRecompile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.get_shadow_caster_material

  call-seq:
    get_shadow_caster_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_shadow_caster_material(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);
  {
    try {
      result = ((Ogre::Technique const *)arg1)->getShadowCasterMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_shadow_caster_material

  call-seq:
    set_shadow_caster_material(MaterialPtr val)
    set_shadow_caster_material(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_shadow_caster_material__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));
    }
  }
  {
    try {
      (arg1)->setShadowCasterMaterial(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_set_shadow_caster_material__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;
  }
  {
    try {
      (arg1)->setShadowCasterMaterial((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_set_shadow_caster_material(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_set_shadow_caster_material__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_set_shadow_caster_material__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Technique.set_shadow_caster_material", 
    "    void Technique.set_shadow_caster_material(Ogre::MaterialPtr val)\n"
    "    void Technique.set_shadow_caster_material(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.get_shadow_receiver_material

  call-seq:
    get_shadow_receiver_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_shadow_receiver_material(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);
  {
    try {
      result = ((Ogre::Technique const *)arg1)->getShadowReceiverMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_shadow_receiver_material

  call-seq:
    set_shadow_receiver_material(MaterialPtr val)
    set_shadow_receiver_material(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_shadow_receiver_material__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));
    }
  }
  {
    try {
      (arg1)->setShadowReceiverMaterial(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_set_shadow_receiver_material__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;
  }
  {
    try {
      (arg1)->setShadowReceiverMaterial((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_set_shadow_receiver_material(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_set_shadow_receiver_material__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_set_shadow_receiver_material__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Technique.set_shadow_receiver_material", 
    "    void Technique.set_shadow_receiver_material(Ogre::MaterialPtr val)\n"
    "    void Technique.set_shadow_receiver_material(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_point_size

  call-seq:
    set_point_size(Real ps)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_point_size(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);
  {
    try {
      (arg1)->setPointSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_ambient

  call-seq:
    set_ambient(Real red, Real green, Real blue)
    set_ambient(ColourValue ambient)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_ambient__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);
  {
    try {
      (arg1)->setAmbient(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_set_ambient__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);
  {
    try {
      (arg1)->setAmbient((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_set_ambient(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_set_ambient__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_set_ambient__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Technique.set_ambient", 
    "    void Technique.set_ambient(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Technique.set_ambient(Ogre::ColourValue const &ambient)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_diffuse

  call-seq:
    set_diffuse(Real red, Real green, Real blue, Real alpha)
    set_diffuse(ColourValue diffuse)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_diffuse__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);
  {
    try {
      (arg1)->setDiffuse(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_set_diffuse__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);
  {
    try {
      (arg1)->setDiffuse((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_set_diffuse(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_set_diffuse__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_set_diffuse__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Technique.set_diffuse", 
    "    void Technique.set_diffuse(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Technique.set_diffuse(Ogre::ColourValue const &diffuse)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_specular

  call-seq:
    set_specular(Real red, Real green, Real blue, Real alpha)
    set_specular(ColourValue specular)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_specular__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);
  {
    try {
      (arg1)->setSpecular(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_set_specular__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);
  {
    try {
      (arg1)->setSpecular((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_set_specular(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_set_specular__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_set_specular__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Technique.set_specular", 
    "    void Technique.set_specular(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Technique.set_specular(Ogre::ColourValue const &specular)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_shininess

  call-seq:
    set_shininess(Real val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_shininess(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);
  {
    try {
      (arg1)->setShininess(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_self_illumination

  call-seq:
    set_self_illumination(Real red, Real green, Real blue)
    set_self_illumination(ColourValue selfIllum)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_self_illumination__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);
  {
    try {
      (arg1)->setSelfIllumination(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_set_self_illumination__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);
  {
    try {
      (arg1)->setSelfIllumination((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_set_self_illumination(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_set_self_illumination__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_set_self_illumination__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Technique.set_self_illumination", 
    "    void Technique.set_self_illumination(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Technique.set_self_illumination(Ogre::ColourValue const &selfIllum)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_depth_check_enabled

  call-seq:
    set_depth_check_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_depth_check_enabled(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);
  {
    try {
      (arg1)->setDepthCheckEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_depth_write_enabled

  call-seq:
    set_depth_write_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_depth_write_enabled(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);
  {
    try {
      (arg1)->setDepthWriteEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_depth_function

  call-seq:
    set_depth_function(CompareFunction func)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_depth_function(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);
  {
    try {
      (arg1)->setDepthFunction(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_colour_write_enabled

  call-seq:
    set_colour_write_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_colour_write_enabled(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);
  {
    try {
      (arg1)->setColourWriteEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_culling_mode

  call-seq:
    set_culling_mode(CullingMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_culling_mode(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);
  {
    try {
      (arg1)->setCullingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_manual_culling_mode

  call-seq:
    set_manual_culling_mode(ManualCullingMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_manual_culling_mode(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);
  {
    try {
      (arg1)->setManualCullingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_lighting_enabled

  call-seq:
    set_lighting_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_lighting_enabled(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);
  {
    try {
      (arg1)->setLightingEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_shading_mode

  call-seq:
    set_shading_mode(ShadeOptions mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_shading_mode(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);
  {
    try {
      (arg1)->setShadingMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_fog

  call-seq:
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White, 
    Real expDensity=0.001, Real linearStart=0.0, 
    Real linearEnd=1.0)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White, 
    Real expDensity=0.001, Real linearStart=0.0)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White, 
    Real expDensity=0.001)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE, ColourValue colour=White)
    set_fog(bool overrideScene, FogMode mode=FOG_NONE)
    set_fog(bool overrideScene)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_set_fog(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_set_fog__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_set_fog__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_set_fog__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_set_fog__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_set_fog__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_set_fog__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Technique.set_fog", 
    "    void Technique.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart, Ogre::Real linearEnd)\n"
    "    void Technique.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart)\n"
    "    void Technique.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity)\n"
    "    void Technique.set_fog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour)\n"
    "    void Technique.set_fog(bool overrideScene, Ogre::FogMode mode)\n"
    "    void Technique.set_fog(bool overrideScene)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_depth_bias

  call-seq:
    set_depth_bias(float constantBias, float slopeScaleBias)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_depth_bias(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);
  {
    try {
      (arg1)->setDepthBias(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_texture_filtering

  call-seq:
    set_texture_filtering(TextureFilterOptions filterType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_texture_filtering(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);
  {
    try {
      (arg1)->setTextureFiltering(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_texture_anisotropy

  call-seq:
    set_texture_anisotropy(unsigned int maxAniso)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_texture_anisotropy(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);
  {
    try {
      (arg1)->setTextureAnisotropy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_scene_blending

  call-seq:
    set_scene_blending(SceneBlendType sbt)
    set_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_scene_blending__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);
  {
    try {
      (arg1)->setSceneBlending(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_separate_scene_blending

  call-seq:
    set_separate_scene_blending(SceneBlendType sbt, SceneBlendType sbta)
    set_separate_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, 
    SceneBlendFactor sourceFactorAlpha, 
    SceneBlendFactor destFactorAlpha)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_separate_scene_blending__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);
  {
    try {
      (arg1)->setSeparateSceneBlending(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_scene_blending

  call-seq:
    set_scene_blending(SceneBlendType sbt)
    set_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_scene_blending__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);
  {
    try {
      (arg1)->setSceneBlending(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_set_scene_blending(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_set_scene_blending__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_set_scene_blending__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Technique.set_scene_blending", 
    "    void Technique.set_scene_blending(Ogre::SceneBlendType const sbt)\n"
    "    void Technique.set_scene_blending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_separate_scene_blending

  call-seq:
    set_separate_scene_blending(SceneBlendType sbt, SceneBlendType sbta)
    set_separate_scene_blending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, 
    SceneBlendFactor sourceFactorAlpha, 
    SceneBlendFactor destFactorAlpha)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_separate_scene_blending__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);
  {
    try {
      (arg1)->setSeparateSceneBlending(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_set_separate_scene_blending(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_set_separate_scene_blending__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_set_separate_scene_blending__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Technique.set_separate_scene_blending", 
    "    void Technique.set_separate_scene_blending(Ogre::SceneBlendType const sbt, Ogre::SceneBlendType const sbta)\n"
    "    void Technique.set_separate_scene_blending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor, Ogre::SceneBlendFactor const sourceFactorAlpha, Ogre::SceneBlendFactor const destFactorAlpha)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_lod_index

  call-seq:
    set_lod_index(unsigned short index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_lod_index(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);
  {
    try {
      (arg1)->setLodIndex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.get_lod_index

  call-seq:
    get_lod_index -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_lod_index(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);
  {
    try {
      result = (unsigned short)((Ogre::Technique const *)arg1)->getLodIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_scheme_name

  call-seq:
    set_scheme_name(String schemeName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_scheme_name(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;
  }
  {
    try {
      (arg1)->setSchemeName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Technique.get_scheme_name

  call-seq:
    get_scheme_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_scheme_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Technique const *)arg1)->getSchemeName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique._get_scheme_index

  call-seq:
    _get_scheme_index -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique__get_scheme_index(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);
  {
    try {
      result = (unsigned short)((Ogre::Technique const *)arg1)->_getSchemeIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.is_depth_write_enabled

  call-seq:
    is_depth_write_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_is_depth_write_enabled(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);
  {
    try {
      result = (bool)((Ogre::Technique const *)arg1)->isDepthWriteEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.is_depth_check_enabled

  call-seq:
    is_depth_check_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_is_depth_check_enabled(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);
  {
    try {
      result = (bool)((Ogre::Technique const *)arg1)->isDepthCheckEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.has_colour_write_disabled

  call-seq:
    has_colour_write_disabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_has_colour_write_disabled(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);
  {
    try {
      result = (bool)((Ogre::Technique const *)arg1)->hasColourWriteDisabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.set_name

  call-seq:
    set_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_set_name(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;
  }
  {
    try {
      (arg1)->setName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Technique.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Technique const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.apply_texture_aliases

  call-seq:
    apply_texture_aliases(AliasTextureNamePairList aliasList, bool apply=true) -> bool
    apply_texture_aliases(AliasTextureNamePairList aliasList) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_apply_texture_aliases__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);
  {
    try {
      result = (bool)((Ogre::Technique const *)arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_apply_texture_aliases__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);
  {
    try {
      result = (bool)((Ogre::Technique const *)arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_apply_texture_aliases(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_apply_texture_aliases__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_apply_texture_aliases__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Technique.apply_texture_aliases", 
    "    bool Technique.apply_texture_aliases(Ogre::AliasTextureNamePairList const &aliasList, bool const apply)\n"
    "    bool Technique.apply_texture_aliases(Ogre::AliasTextureNamePairList const &aliasList)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.add_gpuvendor_rule

  call-seq:
    add_gpuvendor_rule(GPUVendor vendor, IncludeOrExclude includeOrExclude)
    add_gpuvendor_rule(GPUVendorRule rule)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_add_gpuvendor_rule__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);
  {
    try {
      (arg1)->addGPUVendorRule(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_add_gpuvendor_rule__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);
  {
    try {
      (arg1)->addGPUVendorRule((GPUVendorRule const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_add_gpuvendor_rule(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_add_gpuvendor_rule__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_add_gpuvendor_rule__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Technique.add_gpuvendor_rule", 
    "    void Technique.add_gpuvendor_rule(Ogre::GPUVendor vendor, Ogre::Technique::IncludeOrExclude includeOrExclude)\n"
    "    void Technique.add_gpuvendor_rule(GPUVendorRule const &rule)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.remove_gpuvendor_rule

  call-seq:
    remove_gpuvendor_rule(GPUVendor vendor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_remove_gpuvendor_rule(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);
  {
    try {
      (arg1)->removeGPUVendorRule(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Technique.get_gpuvendor_rule_iterator

  call-seq:
    get_gpuvendor_rule_iterator -> GPUVendorRuleIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_gpuvendor_rule_iterator(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);
  {
    try {
      result = ((Ogre::Technique const *)arg1)->getGPUVendorRuleIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Technique.add_gpudevice_name_rule

  call-seq:
    add_gpudevice_name_rule(String devicePattern, IncludeOrExclude includeOrExclude, 
    bool caseSensitive=false)
    add_gpudevice_name_rule(String devicePattern, IncludeOrExclude includeOrExclude)
    add_gpudevice_name_rule(GPUDeviceNameRule rule)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_add_gpudevice_name_rule__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);
  {
    try {
      (arg1)->addGPUDeviceNameRule((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_add_gpudevice_name_rule__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);
  {
    try {
      (arg1)->addGPUDeviceNameRule((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_add_gpudevice_name_rule__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);
  {
    try {
      (arg1)->addGPUDeviceNameRule((GPUDeviceNameRule const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_add_gpudevice_name_rule(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_add_gpudevice_name_rule__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_add_gpudevice_name_rule__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_add_gpudevice_name_rule__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Technique.add_gpudevice_name_rule", 
    "    void Technique.add_gpudevice_name_rule(Ogre::String const &devicePattern, Ogre::Technique::IncludeOrExclude includeOrExclude, bool caseSensitive)\n"
    "    void Technique.add_gpudevice_name_rule(Ogre::String const &devicePattern, Ogre::Technique::IncludeOrExclude includeOrExclude)\n"
    "    void Technique.add_gpudevice_name_rule(GPUDeviceNameRule const &rule)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Technique.remove_gpudevice_name_rule

  call-seq:
    remove_gpudevice_name_rule(String devicePattern)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_remove_gpudevice_name_rule(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;
  }
  {
    try {
      (arg1)->removeGPUDeviceNameRule((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Technique.get_gpudevice_name_rule_iterator

  call-seq:
    get_gpudevice_name_rule_iterator -> GPUDeviceNameRuleIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_gpudevice_name_rule_iterator(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);
  {
    try {
      result = ((Ogre::Technique const *)arg1)->getGPUDeviceNameRuleIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::Technique.get_user_object_bindings

  call-seq:
    get_user_object_bindings -> UserObjectBindings
    get_user_object_bindings -> UserObjectBindings

An instance method.

*/
SWIGINTERN VALUE
_wrap_Technique_get_user_object_bindings__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);
  {
    try {
      result = (Ogre::UserObjectBindings *) &(arg1)->getUserObjectBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_get_user_object_bindings__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);
  {
    try {
      result = (Ogre::UserObjectBindings *) &((Ogre::Technique const *)arg1)->getUserObjectBindings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_get_user_object_bindings(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_get_user_object_bindings__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_get_user_object_bindings__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Technique.get_user_object_bindings", 
    "    Ogre::UserObjectBindings const & Technique.get_user_object_bindings()\n"
    "    Ogre::UserObjectBindings const & Technique.get_user_object_bindings()\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::RenderablePass

  Proxy of C++ Ogre::RenderablePass class


*/
swig_class SwigClassRenderablePass;


/*
  Document-method: Ogre::RenderablePass.renderable

  call-seq:
    renderable -> Renderable

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderablePass.renderable=

  call-seq:
    renderable=(x) -> Renderable

Set new value for attribute.

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



/*
  Document-method: Ogre::RenderablePass.pass

  call-seq:
    pass -> Pass

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderablePass.pass=

  call-seq:
    pass=(x) -> Pass

Set new value for attribute.

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


/*
  Document-method: Ogre::RenderablePass.new

  call-seq:
    RenderablePass.new(Renderable rend, Pass p)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::RenderablePass *)new Ogre::RenderablePass(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderablePass(Ogre::RenderablePass *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::QueuedRenderableVisitor

  Proxy of C++ Ogre::QueuedRenderableVisitor class


*/
swig_class SwigClassQueuedRenderableVisitor;

SWIGINTERN void
free_Ogre_QueuedRenderableVisitor(Ogre::QueuedRenderableVisitor *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::QueuedRenderableVisitor.visit

  call-seq:
    visit(RenderablePass rp)
    visit(Pass p) -> bool
    visit(Renderable r)

An instance method.

*/
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);
  {
    try {
      (arg1)->visit(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (bool)(arg1)->visit((Ogre::Pass const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->visit(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-class: Ogre::QueuedRenderableCollection

  Proxy of C++ Ogre::QueuedRenderableCollection class


*/
swig_class SwigClassQueuedRenderableCollection;


/*
  Document-method: Ogre::OrganisationMode.OM_PASS_GROUP

  call-seq:
    OM_PASS_GROUP -> int

A class method.

*/

/*
  Document-method: Ogre::OrganisationMode.OM_SORT_DESCENDING

  call-seq:
    OM_SORT_DESCENDING -> int

A class method.

*/

/*
  Document-method: Ogre::OrganisationMode.OM_SORT_ASCENDING

  call-seq:
    OM_SORT_ASCENDING -> int

A class method.

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


/*
  Document-method: Ogre::QueuedRenderableCollection.new

  call-seq:
    QueuedRenderableCollection.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::QueuedRenderableCollection *)new Ogre::QueuedRenderableCollection();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::QueuedRenderableCollection.remove_pass_group

  call-seq:
    remove_pass_group(Pass p)

An instance method.

*/
SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_remove_pass_group(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);
  {
    try {
      (arg1)->removePassGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::QueuedRenderableCollection.reset_organisation_modes

  call-seq:
    reset_organisation_modes

An instance method.

*/
SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_reset_organisation_modes(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);
  {
    try {
      (arg1)->resetOrganisationModes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::QueuedRenderableCollection.add_organisation_mode

  call-seq:
    add_organisation_mode(OrganisationMode om)

An instance method.

*/
SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_add_organisation_mode(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);
  {
    try {
      (arg1)->addOrganisationMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::QueuedRenderableCollection.add_renderable

  call-seq:
    add_renderable(Pass pass, Renderable rend)

An instance method.

*/
SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_add_renderable(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);
  {
    try {
      (arg1)->addRenderable(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::QueuedRenderableCollection.sort

  call-seq:
    sort(Camera cam)

An instance method.

*/
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);
  {
    try {
      (arg1)->sort((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::QueuedRenderableCollection.accept_visitor

  call-seq:
    accept_visitor(QueuedRenderableVisitor visitor, OrganisationMode om)

An instance method.

*/
SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_accept_visitor(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);
  {
    try {
      ((Ogre::QueuedRenderableCollection const *)arg1)->acceptVisitor(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::QueuedRenderableCollection.merge

  call-seq:
    merge(QueuedRenderableCollection rhs)

An instance method.

*/
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);
  {
    try {
      (arg1)->merge((Ogre::QueuedRenderableCollection const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RenderPriorityGroup

  Proxy of C++ Ogre::RenderPriorityGroup class


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


/*
  Document-method: Ogre::RenderPriorityGroup.new

  call-seq:
    RenderPriorityGroup.new(RenderQueueGroup parent, bool splitPassesByLightingType, 
    bool splitNoShadowPasses, bool shadowCastersNotReceivers)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::RenderPriorityGroup *)new Ogre::RenderPriorityGroup(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderPriorityGroup(Ogre::RenderPriorityGroup *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderPriorityGroup.get_solids_basic

  call-seq:
    get_solids_basic -> QueuedRenderableCollection

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_get_solids_basic(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);
  {
    try {
      result = (Ogre::QueuedRenderableCollection *) &((Ogre::RenderPriorityGroup const *)arg1)->getSolidsBasic();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__QueuedRenderableCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.get_solids_diffuse_specular

  call-seq:
    get_solids_diffuse_specular -> QueuedRenderableCollection

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_get_solids_diffuse_specular(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);
  {
    try {
      result = (Ogre::QueuedRenderableCollection *) &((Ogre::RenderPriorityGroup const *)arg1)->getSolidsDiffuseSpecular();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__QueuedRenderableCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.get_solids_decal

  call-seq:
    get_solids_decal -> QueuedRenderableCollection

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_get_solids_decal(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);
  {
    try {
      result = (Ogre::QueuedRenderableCollection *) &((Ogre::RenderPriorityGroup const *)arg1)->getSolidsDecal();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__QueuedRenderableCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.get_solids_no_shadow_receive

  call-seq:
    get_solids_no_shadow_receive -> QueuedRenderableCollection

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_get_solids_no_shadow_receive(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);
  {
    try {
      result = (Ogre::QueuedRenderableCollection *) &((Ogre::RenderPriorityGroup const *)arg1)->getSolidsNoShadowReceive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__QueuedRenderableCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.get_transparents_unsorted

  call-seq:
    get_transparents_unsorted -> QueuedRenderableCollection

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_get_transparents_unsorted(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);
  {
    try {
      result = (Ogre::QueuedRenderableCollection *) &((Ogre::RenderPriorityGroup const *)arg1)->getTransparentsUnsorted();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__QueuedRenderableCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.get_transparents

  call-seq:
    get_transparents -> QueuedRenderableCollection

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_get_transparents(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);
  {
    try {
      result = (Ogre::QueuedRenderableCollection *) &((Ogre::RenderPriorityGroup const *)arg1)->getTransparents();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__QueuedRenderableCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.reset_organisation_modes

  call-seq:
    reset_organisation_modes

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_reset_organisation_modes(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);
  {
    try {
      (arg1)->resetOrganisationModes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.add_organisation_mode

  call-seq:
    add_organisation_mode(OrganisationMode om)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_add_organisation_mode(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);
  {
    try {
      (arg1)->addOrganisationMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.default_organisation_mode

  call-seq:
    default_organisation_mode

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_default_organisation_mode(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);
  {
    try {
      (arg1)->defaultOrganisationMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.add_renderable

  call-seq:
    add_renderable(Renderable pRend, Technique pTech)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_add_renderable(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);
  {
    try {
      (arg1)->addRenderable(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.sort

  call-seq:
    sort(Camera cam)

An instance method.

*/
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);
  {
    try {
      (arg1)->sort((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.set_split_passes_by_lighting_type

  call-seq:
    set_split_passes_by_lighting_type(bool split)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_set_split_passes_by_lighting_type(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);
  {
    try {
      (arg1)->setSplitPassesByLightingType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.set_split_no_shadow_passes

  call-seq:
    set_split_no_shadow_passes(bool split)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_set_split_no_shadow_passes(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);
  {
    try {
      (arg1)->setSplitNoShadowPasses(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.set_shadow_casters_cannot_be_receivers

  call-seq:
    set_shadow_casters_cannot_be_receivers(bool ind)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_set_shadow_casters_cannot_be_receivers(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);
  {
    try {
      (arg1)->setShadowCastersCannotBeReceivers(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.merge

  call-seq:
    merge(RenderPriorityGroup rhs)

An instance method.

*/
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);
  {
    try {
      (arg1)->merge((Ogre::RenderPriorityGroup const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RenderQueueGroup

  Proxy of C++ Ogre::RenderQueueGroup class


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


/*
  Document-method: Ogre::RenderQueueGroup.new

  call-seq:
    RenderQueueGroup.new(RenderQueue parent, bool splitPassesByLightingType, 
    bool splitNoShadowPasses, bool shadowCastersNotReceivers)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::RenderQueueGroup *)new Ogre::RenderQueueGroup(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderQueueGroup(Ogre::RenderQueueGroup *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderQueueGroup.get_iterator

  call-seq:
    get_iterator -> PriorityMapIterator
    get_iterator -> ConstPriorityMapIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueGroup_get_iterator__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);
  {
    try {
      result = (arg1)->getIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_iterator__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);
  {
    try {
      result = ((Ogre::RenderQueueGroup const *)arg1)->getIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_iterator(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_get_iterator__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_get_iterator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "RenderQueueGroup.get_iterator", 
    "    Ogre::RenderQueueGroup::ConstPriorityMapIterator RenderQueueGroup.get_iterator()\n"
    "    Ogre::RenderQueueGroup::ConstPriorityMapIterator RenderQueueGroup.get_iterator()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueGroup.add_renderable

  call-seq:
    add_renderable(Renderable pRend, Technique pTech, ushort priority)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueGroup_add_renderable(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);
  {
    try {
      (arg1)->addRenderable(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      (arg1)->clear(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::RenderQueueGroup.set_shadows_enabled

  call-seq:
    set_shadows_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueGroup_set_shadows_enabled(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);
  {
    try {
      (arg1)->setShadowsEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueGroup.get_shadows_enabled

  call-seq:
    get_shadows_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueGroup_get_shadows_enabled(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);
  {
    try {
      result = (bool)((Ogre::RenderQueueGroup const *)arg1)->getShadowsEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueGroup.set_split_passes_by_lighting_type

  call-seq:
    set_split_passes_by_lighting_type(bool split)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueGroup_set_split_passes_by_lighting_type(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);
  {
    try {
      (arg1)->setSplitPassesByLightingType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueGroup.set_split_no_shadow_passes

  call-seq:
    set_split_no_shadow_passes(bool split)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueGroup_set_split_no_shadow_passes(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);
  {
    try {
      (arg1)->setSplitNoShadowPasses(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueGroup.set_shadow_casters_cannot_be_receivers

  call-seq:
    set_shadow_casters_cannot_be_receivers(bool ind)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueGroup_set_shadow_casters_cannot_be_receivers(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);
  {
    try {
      (arg1)->setShadowCastersCannotBeReceivers(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueGroup.reset_organisation_modes

  call-seq:
    reset_organisation_modes

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueGroup_reset_organisation_modes(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);
  {
    try {
      (arg1)->resetOrganisationModes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueGroup.add_organisation_mode

  call-seq:
    add_organisation_mode(OrganisationMode om)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueGroup_add_organisation_mode(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);
  {
    try {
      (arg1)->addOrganisationMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueGroup.default_organisation_mode

  call-seq:
    default_organisation_mode

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueGroup_default_organisation_mode(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);
  {
    try {
      (arg1)->defaultOrganisationMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueGroup.merge

  call-seq:
    merge(RenderQueueGroup rhs)

An instance method.

*/
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);
  {
    try {
      (arg1)->merge((Ogre::RenderQueueGroup const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RenderQueueInvocation

  Proxy of C++ Ogre::RenderQueueInvocation class


*/
swig_class SwigClassRenderQueueInvocation;


/*
  Document-method: Ogre::RenderQueueInvocation.new

  call-seq:
    RenderQueueInvocation.new(uint8 renderQueueGroupID, String invocationName=BLANK)
    RenderQueueInvocation.new(uint8 renderQueueGroupID)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderQueueInvocation *)new Ogre::RenderQueueInvocation(arg1,(Ogre::String const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::RenderQueueInvocation *)new Ogre::RenderQueueInvocation(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::RenderQueueInvocation.get_render_queue_group_id

  call-seq:
    get_render_queue_group_id -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueInvocation_get_render_queue_group_id(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::RenderQueueInvocation const *)arg1)->getRenderQueueGroupID();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocation.get_invocation_name

  call-seq:
    get_invocation_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueInvocation_get_invocation_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::RenderQueueInvocation const *)arg1)->getInvocationName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocation.set_solids_organisation

  call-seq:
    set_solids_organisation(OrganisationMode org)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueInvocation_set_solids_organisation(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);
  {
    try {
      (arg1)->setSolidsOrganisation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocation.get_solids_organisation

  call-seq:
    get_solids_organisation -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueInvocation_get_solids_organisation(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);
  {
    try {
      result = (Ogre::QueuedRenderableCollection::OrganisationMode)((Ogre::RenderQueueInvocation const *)arg1)->getSolidsOrganisation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocation.set_suppress_shadows

  call-seq:
    set_suppress_shadows(bool suppress)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueInvocation_set_suppress_shadows(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);
  {
    try {
      (arg1)->setSuppressShadows(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocation.get_suppress_shadows

  call-seq:
    get_suppress_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueInvocation_get_suppress_shadows(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);
  {
    try {
      result = (bool)((Ogre::RenderQueueInvocation const *)arg1)->getSuppressShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocation.set_suppress_render_state_changes

  call-seq:
    set_suppress_render_state_changes(bool suppress)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueInvocation_set_suppress_render_state_changes(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);
  {
    try {
      (arg1)->setSuppressRenderStateChanges(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocation.get_suppress_render_state_changes

  call-seq:
    get_suppress_render_state_changes -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueInvocation_get_suppress_render_state_changes(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);
  {
    try {
      result = (bool)((Ogre::RenderQueueInvocation const *)arg1)->getSuppressRenderStateChanges();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocation.invoke

  call-seq:
    invoke(RenderQueueGroup group, SceneManager targetSceneManager)

An instance method.

*/
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);
  {
    try {
      (arg1)->invoke(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocation.RENDER_QUEUE_INVOCATION_SHADOWS

  call-seq:
    RENDER_QUEUE_INVOCATION_SHADOWS -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::RenderQueueInvocation.RENDER_QUEUE_INVOCATION_SHADOWS=

  call-seq:
    RENDER_QUEUE_INVOCATION_SHADOWS=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::RenderQueueInvocation.RenderQueueInvocation_RENDER_QUEUE_INVOCATION_SHADOWS

  call-seq:
    RenderQueueInvocation_RENDER_QUEUE_INVOCATION_SHADOWS -> String

Get value of attribute.

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



/*
  Document-method: Ogre::RenderQueueInvocation.RenderQueueInvocation_RENDER_QUEUE_INVOCATION_SHADOWS=

  call-seq:
    RenderQueueInvocation_RENDER_QUEUE_INVOCATION_SHADOWS=(x) -> String

Set new value for attribute.

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



/*
  Document-class: Ogre::RenderQueueInvocationSequence

  Proxy of C++ Ogre::RenderQueueInvocationSequence class


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


/*
  Document-method: Ogre::RenderQueueInvocationSequence.new

  call-seq:
    RenderQueueInvocationSequence.new(String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderQueueInvocationSequence *)new Ogre::RenderQueueInvocationSequence((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::RenderQueueInvocationSequence.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderQueueInvocationSequence_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::RenderQueueInvocationSequence const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocationSequence.add

  call-seq:
    add(uint8 renderQueueGroupID, String invocationName) -> RenderQueueInvocation
    add(RenderQueueInvocation i)

An instance method.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderQueueInvocation *)(arg1)->add(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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);
  {
    try {
      (arg1)->add(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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);
  {
    try {
      result = ((Ogre::RenderQueueInvocationSequence const *)arg1)->size();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocationSequence.get

  call-seq:
    get(size_t index) -> RenderQueueInvocation

An instance method.

*/
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);
  {
    try {
      result = (Ogre::RenderQueueInvocation *)(arg1)->get(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueueInvocation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocationSequence.remove

  call-seq:
    remove(size_t index)

An instance method.

*/
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);
  {
    try {
      (arg1)->remove(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      result = (arg1)->iterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-class: Ogre::RenderSystemCapabilitiesManager

  Proxy of C++ Ogre::RenderSystemCapabilitiesManager class


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


/*
  Document-method: Ogre::RenderSystemCapabilitiesManager.new

  call-seq:
    RenderSystemCapabilitiesManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderSystemCapabilitiesManager *)new Ogre::RenderSystemCapabilitiesManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderSystemCapabilitiesManager(Ogre::RenderSystemCapabilitiesManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderSystemCapabilitiesManager.parse_capabilities_from_archive

  call-seq:
    parse_capabilities_from_archive(String filename, String archiveType, bool recursive=true)
    parse_capabilities_from_archive(String filename, String archiveType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager_parse_capabilities_from_archive__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);
  {
    try {
      (arg1)->parseCapabilitiesFromArchive((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_parse_capabilities_from_archive__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;
  }
  {
    try {
      (arg1)->parseCapabilitiesFromArchive((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_parse_capabilities_from_archive(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_parse_capabilities_from_archive__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_parse_capabilities_from_archive__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderSystemCapabilitiesManager.parse_capabilities_from_archive", 
    "    void RenderSystemCapabilitiesManager.parse_capabilities_from_archive(Ogre::String const &filename, Ogre::String const &archiveType, bool recursive)\n"
    "    void RenderSystemCapabilitiesManager.parse_capabilities_from_archive(Ogre::String const &filename, Ogre::String const &archiveType)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilitiesManager.load_parsed_capabilities

  call-seq:
    load_parsed_capabilities(String name) -> RenderSystemCapabilities

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager_load_parsed_capabilities(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;
  }
  {
    try {
      result = (Ogre::RenderSystemCapabilities *)(arg1)->loadParsedCapabilities((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilitiesManager.get_capabilities

  call-seq:
    get_capabilities -> Ogre::map<(Ogre::String,p.Ogre::RenderSystemCapabilities,std::less<(Ogre::String)>,Ogre::STLAllocator<(std::pair<(q(const).Ogre::String,p.Ogre::RenderSystemCapabilities)>,Ogre::GeneralAllocPolicy)>)>::type

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager_get_capabilities(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);
  {
    try {
      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();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::RenderSystemCapabilitiesManager._add_render_system_capabilities

  call-seq:
    _add_render_system_capabilities(String name, RenderSystemCapabilities caps)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager__add_render_system_capabilities(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);
  {
    try {
      (arg1)->_addRenderSystemCapabilities((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilitiesManager.get_singleton

  call-seq:
    get_singleton -> RenderSystemCapabilitiesManager

A class method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::RenderSystemCapabilitiesManager *) &Ogre::RenderSystemCapabilitiesManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystemCapabilitiesManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilitiesManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> RenderSystemCapabilitiesManager

A class method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::RenderSystemCapabilitiesManager *)Ogre::RenderSystemCapabilitiesManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystemCapabilitiesManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RenderSystemCapabilitiesSerializer

  Proxy of C++ Ogre::RenderSystemCapabilitiesSerializer class


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


/*
  Document-method: Ogre::RenderSystemCapabilitiesSerializer.new

  call-seq:
    RenderSystemCapabilitiesSerializer.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderSystemCapabilitiesSerializer *)new Ogre::RenderSystemCapabilitiesSerializer();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderSystemCapabilitiesSerializer(Ogre::RenderSystemCapabilitiesSerializer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderSystemCapabilitiesSerializer.write_script

  call-seq:
    write_script(RenderSystemCapabilities caps, String name, String filename)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesSerializer_write_script(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;
  }
  {
    try {
      (arg1)->writeScript((Ogre::RenderSystemCapabilities const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilitiesSerializer.write_string

  call-seq:
    write_string(RenderSystemCapabilities caps, String name) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesSerializer_write_string(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;
  }
  {
    try {
      result = (arg1)->writeString((Ogre::RenderSystemCapabilities const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderSystemCapabilitiesSerializer.parse_script

  call-seq:
    parse_script(DataStreamPtr stream)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesSerializer_parse_script(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);
  {
    try {
      (arg1)->parseScript(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RenderWindow < Ogre::Ogre::RenderTarget

  Proxy of C++ Ogre::RenderWindow class


*/
swig_class SwigClassRenderWindow;


/*
  Document-method: Ogre::RenderWindow.create

  call-seq:
    create(String name, unsigned int width, unsigned int height, 
    bool fullScreen, NameValuePairList miscParams)

An instance method.

*/
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);
  {
    try {
      (arg1)->create((Ogre::String const &)*arg2,arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.set_fullscreen

  call-seq:
    set_fullscreen(bool fullScreen, unsigned int width, unsigned int height)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_set_fullscreen(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);
  {
    try {
      (arg1)->setFullscreen(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.destroy

  call-seq:
    destroy

An instance method.

*/
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);
  {
    try {
      (arg1)->destroy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      (arg1)->resize(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.window_moved_or_resized

  call-seq:
    window_moved_or_resized

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_window_moved_or_resized(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);
  {
    try {
      (arg1)->windowMovedOrResized();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.reposition

  call-seq:
    reposition(int left, int top)

An instance method.

*/
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);
  {
    try {
      (arg1)->reposition(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.is_visible

  call-seq:
    is_visible -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_is_visible(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);
  {
    try {
      result = (bool)((Ogre::RenderWindow const *)arg1)->isVisible();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.set_visible

  call-seq:
    set_visible(bool visible)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_set_visible(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);
  {
    try {
      (arg1)->setVisible(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.is_hidden

  call-seq:
    is_hidden -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_is_hidden(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);
  {
    try {
      result = (bool)((Ogre::RenderWindow const *)arg1)->isHidden();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.set_hidden

  call-seq:
    set_hidden(bool hidden)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_set_hidden(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);
  {
    try {
      (arg1)->setHidden(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.set_vsync_enabled

  call-seq:
    set_vsync_enabled(bool vsync)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_set_vsync_enabled(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);
  {
    try {
      (arg1)->setVSyncEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.is_vsync_enabled

  call-seq:
    is_vsync_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_is_vsync_enabled(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);
  {
    try {
      result = (bool)((Ogre::RenderWindow const *)arg1)->isVSyncEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.set_vsync_interval

  call-seq:
    set_vsync_interval(unsigned int interval)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_set_vsync_interval(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);
  {
    try {
      (arg1)->setVSyncInterval(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.get_vsync_interval

  call-seq:
    get_vsync_interval -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_get_vsync_interval(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);
  {
    try {
      result = (unsigned int)((Ogre::RenderWindow const *)arg1)->getVSyncInterval();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.is_active

  call-seq:
    is_active -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_is_active(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);
  {
    try {
      result = (bool)((Ogre::RenderWindow const *)arg1)->isActive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.is_closed

  call-seq:
    is_closed -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_is_closed(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);
  {
    try {
      result = (bool)((Ogre::RenderWindow const *)arg1)->isClosed();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.is_primary

  call-seq:
    is_primary -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_is_primary(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);
  {
    try {
      result = (bool)((Ogre::RenderWindow const *)arg1)->isPrimary();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.is_full_screen

  call-seq:
    is_full_screen -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_is_full_screen(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);
  {
    try {
      result = (bool)((Ogre::RenderWindow const *)arg1)->isFullScreen();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.get_metrics

  call-seq:
    get_metrics(unsigned int width, unsigned int height, unsigned int colourDepth, 
    int left, int top)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_get_metrics(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);
  {
    try {
      (arg1)->getMetrics(*arg2,*arg3,*arg4,*arg5,*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.suggest_pixel_format

  call-seq:
    suggest_pixel_format -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_suggest_pixel_format(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);
  {
    try {
      result = (Ogre::PixelFormat)((Ogre::RenderWindow const *)arg1)->suggestPixelFormat();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.is_deactivated_on_focus_change

  call-seq:
    is_deactivated_on_focus_change -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_is_deactivated_on_focus_change(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);
  {
    try {
      result = (bool)((Ogre::RenderWindow const *)arg1)->isDeactivatedOnFocusChange();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.set_deactivate_on_focus_change

  call-seq:
    set_deactivate_on_focus_change(bool deactivate)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RenderWindow_set_deactivate_on_focus_change(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);
  {
    try {
      (arg1)->setDeactivateOnFocusChange(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderWindow(Ogre::RenderWindow *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::WorkQueue

  Proxy of C++ Ogre::WorkQueue class


*/
swig_class SwigClassWorkQueue;

SWIGINTERN void
free_Ogre_WorkQueue(Ogre::WorkQueue *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::WorkQueue.startup

  call-seq:
    startup(bool forceRestart=true)
    startup

An instance method.

*/
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);
  {
    try {
      (arg1)->startup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->startup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::WorkQueue.add_request_handler

  call-seq:
    add_request_handler(uint16 channel, RequestHandler rh)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_add_request_handler(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);
  {
    try {
      (arg1)->addRequestHandler(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.remove_request_handler

  call-seq:
    remove_request_handler(uint16 channel, RequestHandler rh)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_remove_request_handler(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);
  {
    try {
      (arg1)->removeRequestHandler(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.add_response_handler

  call-seq:
    add_response_handler(uint16 channel, ResponseHandler rh)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_add_response_handler(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);
  {
    try {
      (arg1)->addResponseHandler(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.remove_response_handler

  call-seq:
    remove_response_handler(uint16 channel, ResponseHandler rh)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_remove_response_handler(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);
  {
    try {
      (arg1)->removeResponseHandler(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.add_request

  call-seq:
    add_request(uint16 channel, uint16 requestType, Any rData, uint8 retryCount=0, 
    bool forceSynchronous=false) -> RequestID
    add_request(uint16 channel, uint16 requestType, Any rData, uint8 retryCount=0) -> RequestID
    add_request(uint16 channel, uint16 requestType, Any rData) -> RequestID

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_add_request__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);
  {
    try {
      result = (Ogre::WorkQueue::RequestID)(arg1)->addRequest(arg2,arg3,(Ogre::Any const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_add_request__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);
  {
    try {
      result = (Ogre::WorkQueue::RequestID)(arg1)->addRequest(arg2,arg3,(Ogre::Any const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_add_request__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);
  {
    try {
      result = (Ogre::WorkQueue::RequestID)(arg1)->addRequest(arg2,arg3,(Ogre::Any const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_WorkQueue_add_request(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_add_request__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_add_request__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_add_request__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "WorkQueue.add_request", 
    "    Ogre::WorkQueue::RequestID WorkQueue.add_request(Ogre::uint16 channel, Ogre::uint16 requestType, Ogre::Any const &rData, Ogre::uint8 retryCount, bool forceSynchronous)\n"
    "    Ogre::WorkQueue::RequestID WorkQueue.add_request(Ogre::uint16 channel, Ogre::uint16 requestType, Ogre::Any const &rData, Ogre::uint8 retryCount)\n"
    "    Ogre::WorkQueue::RequestID WorkQueue.add_request(Ogre::uint16 channel, Ogre::uint16 requestType, Ogre::Any const &rData)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.abort_request

  call-seq:
    abort_request(RequestID id)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_abort_request(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);
  {
    try {
      (arg1)->abortRequest(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.abort_requests_by_channel

  call-seq:
    abort_requests_by_channel(uint16 channel)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_abort_requests_by_channel(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);
  {
    try {
      (arg1)->abortRequestsByChannel(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.abort_all_requests

  call-seq:
    abort_all_requests

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_abort_all_requests(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);
  {
    try {
      (arg1)->abortAllRequests();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.set_paused

  call-seq:
    set_paused(bool pause)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_set_paused(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);
  {
    try {
      (arg1)->setPaused(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.is_paused

  call-seq:
    is_paused -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_is_paused(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);
  {
    try {
      result = (bool)((Ogre::WorkQueue const *)arg1)->isPaused();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.set_requests_accepted

  call-seq:
    set_requests_accepted(bool accept)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_set_requests_accepted(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);
  {
    try {
      (arg1)->setRequestsAccepted(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.get_requests_accepted

  call-seq:
    get_requests_accepted -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_get_requests_accepted(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);
  {
    try {
      result = (bool)((Ogre::WorkQueue const *)arg1)->getRequestsAccepted();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.process_responses

  call-seq:
    process_responses

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_process_responses(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);
  {
    try {
      (arg1)->processResponses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.get_response_processing_time_limit

  call-seq:
    get_response_processing_time_limit -> unsigned long

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_get_response_processing_time_limit(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);
  {
    try {
      result = (unsigned long)((Ogre::WorkQueue const *)arg1)->getResponseProcessingTimeLimit();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.set_response_processing_time_limit

  call-seq:
    set_response_processing_time_limit(unsigned long ms)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_set_response_processing_time_limit(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);
  {
    try {
      (arg1)->setResponseProcessingTimeLimit(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.shutdown

  call-seq:
    shutdown

An instance method.

*/
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);
  {
    try {
      (arg1)->shutdown();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WorkQueue.get_channel

  call-seq:
    get_channel(String channelName) -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_WorkQueue_get_channel(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;
  }
  {
    try {
      result = (Ogre::uint16)(arg1)->getChannel((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-class: Ogre::DefaultWorkQueueBase < Ogre::Ogre::WorkQueue

  Proxy of C++ Ogre::DefaultWorkQueueBase class


*/
swig_class SwigClassDefaultWorkQueueBase;

SWIGINTERN void
free_Ogre_DefaultWorkQueueBase(Ogre::DefaultWorkQueueBase *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DefaultWorkQueueBase.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::DefaultWorkQueueBase const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.get_worker_thread_count

  call-seq:
    get_worker_thread_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_get_worker_thread_count(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);
  {
    try {
      result = ((Ogre::DefaultWorkQueueBase const *)arg1)->getWorkerThreadCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.set_worker_thread_count

  call-seq:
    set_worker_thread_count(size_t c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_set_worker_thread_count(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);
  {
    try {
      (arg1)->setWorkerThreadCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.get_workers_can_access_render_system

  call-seq:
    get_workers_can_access_render_system -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_get_workers_can_access_render_system(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);
  {
    try {
      result = (bool)((Ogre::DefaultWorkQueueBase const *)arg1)->getWorkersCanAccessRenderSystem();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.set_workers_can_access_render_system

  call-seq:
    set_workers_can_access_render_system(bool access)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_set_workers_can_access_render_system(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);
  {
    try {
      (arg1)->setWorkersCanAccessRenderSystem(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase._process_next_request

  call-seq:
    _process_next_request

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase__process_next_request(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);
  {
    try {
      (arg1)->_processNextRequest();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase._thread_main

  call-seq:
    _thread_main

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase__thread_main(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);
  {
    try {
      (arg1)->_threadMain();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.is_shutting_down

  call-seq:
    is_shutting_down -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_is_shutting_down(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);
  {
    try {
      result = (bool)((Ogre::DefaultWorkQueueBase const *)arg1)->isShuttingDown();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.add_request_handler

  call-seq:
    add_request_handler(uint16 channel, RequestHandler rh)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_add_request_handler(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);
  {
    try {
      (arg1)->addRequestHandler(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.remove_request_handler

  call-seq:
    remove_request_handler(uint16 channel, RequestHandler rh)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_remove_request_handler(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);
  {
    try {
      (arg1)->removeRequestHandler(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.add_response_handler

  call-seq:
    add_response_handler(uint16 channel, ResponseHandler rh)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_add_response_handler(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);
  {
    try {
      (arg1)->addResponseHandler(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.remove_response_handler

  call-seq:
    remove_response_handler(uint16 channel, ResponseHandler rh)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_remove_response_handler(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);
  {
    try {
      (arg1)->removeResponseHandler(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.add_request

  call-seq:
    add_request(uint16 channel, uint16 requestType, Any rData, uint8 retryCount=0, 
    bool forceSynchronous=false) -> RequestID
    add_request(uint16 channel, uint16 requestType, Any rData, uint8 retryCount=0) -> RequestID
    add_request(uint16 channel, uint16 requestType, Any rData) -> RequestID

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_add_request__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);
  {
    try {
      result = (Ogre::WorkQueue::RequestID)(arg1)->addRequest(arg2,arg3,(Ogre::Any const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_add_request__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);
  {
    try {
      result = (Ogre::WorkQueue::RequestID)(arg1)->addRequest(arg2,arg3,(Ogre::Any const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_add_request__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);
  {
    try {
      result = (Ogre::WorkQueue::RequestID)(arg1)->addRequest(arg2,arg3,(Ogre::Any const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DefaultWorkQueueBase_add_request(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_add_request__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_add_request__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_add_request__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "DefaultWorkQueueBase.add_request", 
    "    Ogre::WorkQueue::RequestID DefaultWorkQueueBase.add_request(Ogre::uint16 channel, Ogre::uint16 requestType, Ogre::Any const &rData, Ogre::uint8 retryCount, bool forceSynchronous)\n"
    "    Ogre::WorkQueue::RequestID DefaultWorkQueueBase.add_request(Ogre::uint16 channel, Ogre::uint16 requestType, Ogre::Any const &rData, Ogre::uint8 retryCount)\n"
    "    Ogre::WorkQueue::RequestID DefaultWorkQueueBase.add_request(Ogre::uint16 channel, Ogre::uint16 requestType, Ogre::Any const &rData)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.abort_request

  call-seq:
    abort_request(RequestID id)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_abort_request(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);
  {
    try {
      (arg1)->abortRequest(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.abort_requests_by_channel

  call-seq:
    abort_requests_by_channel(uint16 channel)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_abort_requests_by_channel(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);
  {
    try {
      (arg1)->abortRequestsByChannel(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.abort_all_requests

  call-seq:
    abort_all_requests

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_abort_all_requests(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);
  {
    try {
      (arg1)->abortAllRequests();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.set_paused

  call-seq:
    set_paused(bool pause)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_set_paused(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);
  {
    try {
      (arg1)->setPaused(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.is_paused

  call-seq:
    is_paused -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_is_paused(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);
  {
    try {
      result = (bool)((Ogre::DefaultWorkQueueBase const *)arg1)->isPaused();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.set_requests_accepted

  call-seq:
    set_requests_accepted(bool accept)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_set_requests_accepted(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);
  {
    try {
      (arg1)->setRequestsAccepted(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.get_requests_accepted

  call-seq:
    get_requests_accepted -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_get_requests_accepted(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);
  {
    try {
      result = (bool)((Ogre::DefaultWorkQueueBase const *)arg1)->getRequestsAccepted();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.process_responses

  call-seq:
    process_responses

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_process_responses(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);
  {
    try {
      (arg1)->processResponses();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.get_response_processing_time_limit

  call-seq:
    get_response_processing_time_limit -> unsigned long

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_get_response_processing_time_limit(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);
  {
    try {
      result = (unsigned long)((Ogre::DefaultWorkQueueBase const *)arg1)->getResponseProcessingTimeLimit();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DefaultWorkQueueBase.set_response_processing_time_limit

  call-seq:
    set_response_processing_time_limit(unsigned long ms)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_set_response_processing_time_limit(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);
  {
    try {
      (arg1)->setResponseProcessingTimeLimit(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::BackgroundProcessResult

  Proxy of C++ Ogre::BackgroundProcessResult class


*/
swig_class SwigClassBackgroundProcessResult;


/*
  Document-method: Ogre::BackgroundProcessResult.error

  call-seq:
    error -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::BackgroundProcessResult.error=

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

Set new value for attribute.

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



/*
  Document-method: Ogre::BackgroundProcessResult.message

  call-seq:
    message -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::BackgroundProcessResult.message=

  call-seq:
    message=(x) -> String

Set new value for attribute.

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


/*
  Document-method: Ogre::BackgroundProcessResult.new

  call-seq:
    BackgroundProcessResult.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::BackgroundProcessResult *)new Ogre::BackgroundProcessResult();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_BackgroundProcessResult(Ogre::BackgroundProcessResult *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ResourceBackgroundQueue

  Proxy of C++ Ogre::ResourceBackgroundQueue class


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


/*
  Document-method: Ogre::ResourceBackgroundQueue.new

  call-seq:
    ResourceBackgroundQueue.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ResourceBackgroundQueue *)new Ogre::ResourceBackgroundQueue();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ResourceBackgroundQueue(Ogre::ResourceBackgroundQueue *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ResourceBackgroundQueue.initialise

  call-seq:
    initialise

An instance method.

*/
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);
  {
    try {
      (arg1)->initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.shutdown

  call-seq:
    shutdown

An instance method.

*/
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);
  {
    try {
      (arg1)->shutdown();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.initialise_resource_group

  call-seq:
    initialise_resource_group(String name, Listener listener=0) -> BackgroundProcessTicket
    initialise_resource_group(String name) -> BackgroundProcessTicket

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_initialise_resource_group__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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->initialiseResourceGroup((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_initialise_resource_group__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;
  }
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->initialiseResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_initialise_resource_group(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_initialise_resource_group__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_initialise_resource_group__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceBackgroundQueue.initialise_resource_group", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.initialise_resource_group(Ogre::String const &name, Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.initialise_resource_group(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.initialise_all_resource_groups

  call-seq:
    initialise_all_resource_groups(Listener listener=0) -> BackgroundProcessTicket
    initialise_all_resource_groups -> BackgroundProcessTicket

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_initialise_all_resource_groups__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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->initialiseAllResourceGroups(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_initialise_all_resource_groups__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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->initialiseAllResourceGroups();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceBackgroundQueue_initialise_all_resource_groups(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_initialise_all_resource_groups__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_initialise_all_resource_groups__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceBackgroundQueue.initialise_all_resource_groups", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.initialise_all_resource_groups(Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.initialise_all_resource_groups()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.prepare_resource_group

  call-seq:
    prepare_resource_group(String name, Listener listener=0) -> BackgroundProcessTicket
    prepare_resource_group(String name) -> BackgroundProcessTicket

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_prepare_resource_group__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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->prepareResourceGroup((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_prepare_resource_group__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;
  }
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->prepareResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_prepare_resource_group(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_prepare_resource_group__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_prepare_resource_group__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceBackgroundQueue.prepare_resource_group", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.prepare_resource_group(Ogre::String const &name, Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.prepare_resource_group(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.load_resource_group

  call-seq:
    load_resource_group(String name, Listener listener=0) -> BackgroundProcessTicket
    load_resource_group(String name) -> BackgroundProcessTicket

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_load_resource_group__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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->loadResourceGroup((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_load_resource_group__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;
  }
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->loadResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_load_resource_group(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_load_resource_group__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_load_resource_group__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceBackgroundQueue.load_resource_group", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.load_resource_group(Ogre::String const &name, Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.load_resource_group(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.unload

  call-seq:
    unload(String resType, String name, Listener listener=0) -> BackgroundProcessTicket
    unload(String resType, String name) -> BackgroundProcessTicket
    unload(String resType, ResourceHandle handle, Listener listener=0) -> BackgroundProcessTicket
    unload(String resType, ResourceHandle handle) -> BackgroundProcessTicket

An instance method.

*/
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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->unload((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
  }
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->unload((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->unload((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->unload((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.unload_resource_group

  call-seq:
    unload_resource_group(String name, Listener listener=0) -> BackgroundProcessTicket
    unload_resource_group(String name) -> BackgroundProcessTicket

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_unload_resource_group__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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->unloadResourceGroup((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_resource_group__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;
  }
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->unloadResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_resource_group(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_unload_resource_group__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_unload_resource_group__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceBackgroundQueue.unload_resource_group", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.unload_resource_group(Ogre::String const &name, Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.unload_resource_group(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.prepare

  call-seq:
    prepare(String resType, String name, String group, bool isManual=false, 
    ManualResourceLoader loader=0, NameValuePairList loadParams=0, 
    Listener listener=0) -> BackgroundProcessTicket
    prepare(String resType, String name, String group, bool isManual=false, 
    ManualResourceLoader loader=0, NameValuePairList loadParams=0) -> BackgroundProcessTicket
    prepare(String resType, String name, String group, bool isManual=false, 
    ManualResourceLoader loader=0) -> BackgroundProcessTicket
    prepare(String resType, String name, String group, bool isManual=false) -> BackgroundProcessTicket
    prepare(String resType, String name, String group) -> BackgroundProcessTicket

An instance method.

*/
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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,(Ogre::NameValuePairList const *)arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,(Ogre::NameValuePairList const *)arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
  }
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.load

  call-seq:
    load(String resType, String name, String group, bool isManual=false, 
    ManualResourceLoader loader=0, NameValuePairList loadParams=0, 
    Listener listener=0) -> BackgroundProcessTicket
    load(String resType, String name, String group, bool isManual=false, 
    ManualResourceLoader loader=0, NameValuePairList loadParams=0) -> BackgroundProcessTicket
    load(String resType, String name, String group, bool isManual=false, 
    ManualResourceLoader loader=0) -> BackgroundProcessTicket
    load(String resType, String name, String group, bool isManual=false) -> BackgroundProcessTicket
    load(String resType, String name, String group) -> BackgroundProcessTicket

An instance method.

*/
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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,(Ogre::NameValuePairList const *)arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,(Ogre::NameValuePairList const *)arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
  }
  {
    try {
      result = (Ogre::BackgroundProcessTicket)(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.is_process_complete

  call-seq:
    is_process_complete(BackgroundProcessTicket ticket) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_is_process_complete(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);
  {
    try {
      result = (bool)(arg1)->isProcessComplete(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.abort_request

  call-seq:
    abort_request(BackgroundProcessTicket ticket)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_abort_request(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);
  {
    try {
      (arg1)->abortRequest(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.can_handle_request

  call-seq:
    can_handle_request(Request req, WorkQueue srcQ) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_can_handle_request(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);
  {
    try {
      result = (bool)(arg1)->canHandleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.handle_request

  call-seq:
    handle_request(Request req, WorkQueue srcQ) -> Response

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_handle_request(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);
  {
    try {
      result = (Ogre::WorkQueue::Response *)(arg1)->handleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.can_handle_response

  call-seq:
    can_handle_response(Response res, WorkQueue srcQ) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_can_handle_response(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);
  {
    try {
      result = (bool)(arg1)->canHandleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.handle_response

  call-seq:
    handle_response(Response res, WorkQueue srcQ)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_handle_response(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);
  {
    try {
      (arg1)->handleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.get_singleton

  call-seq:
    get_singleton -> ResourceBackgroundQueue

A class method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_get_singleton(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;
  }
  {
    try {
      result = (Ogre::ResourceBackgroundQueue *) &Ogre::ResourceBackgroundQueue::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourceBackgroundQueue.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> ResourceBackgroundQueue

A class method.

*/
SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::ResourceBackgroundQueue *)Ogre::ResourceBackgroundQueue::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RibbonTrail < Ogre::Ogre::BillboardChain

  Proxy of C++ Ogre::RibbonTrail class


*/
swig_class SwigClassRibbonTrail;


/*
  Document-method: Ogre::RibbonTrail.new

  call-seq:
    RibbonTrail.new(String name, size_t maxElements=20, size_t numberOfChains=1, 
    bool useTextureCoords=true, bool useColours=true)
    RibbonTrail.new(String name, size_t maxElements=20, size_t numberOfChains=1, 
    bool useTextureCoords=true)
    RibbonTrail.new(String name, size_t maxElements=20, size_t numberOfChains=1)
    RibbonTrail.new(String name, size_t maxElements=20)
    RibbonTrail.new(String name)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::RibbonTrail *)new Ogre::RibbonTrail((Ogre::String const &)*arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::RibbonTrail *)new Ogre::RibbonTrail((Ogre::String const &)*arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::RibbonTrail *)new Ogre::RibbonTrail((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::RibbonTrail *)new Ogre::RibbonTrail((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::RibbonTrail *)new Ogre::RibbonTrail((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::RibbonTrail.add_node

  call-seq:
    add_node(Node n)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_add_node(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);
  {
    try {
      (arg1)->addNode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.remove_node

  call-seq:
    remove_node(Node n)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_remove_node(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);
  {
    try {
      (arg1)->removeNode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.get_node_iterator

  call-seq:
    get_node_iterator -> NodeIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_get_node_iterator(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);
  {
    try {
      result = ((Ogre::RibbonTrail const *)arg1)->getNodeIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::RibbonTrail.get_chain_index_for_node

  call-seq:
    get_chain_index_for_node(Node n) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_get_chain_index_for_node(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);
  {
    try {
      result = (arg1)->getChainIndexForNode((Ogre::Node const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.set_trail_length

  call-seq:
    set_trail_length(Real len)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_set_trail_length(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);
  {
    try {
      (arg1)->setTrailLength(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.get_trail_length

  call-seq:
    get_trail_length -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_get_trail_length(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);
  {
    try {
      result = (Ogre::Real)((Ogre::RibbonTrail const *)arg1)->getTrailLength();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.set_max_chain_elements

  call-seq:
    set_max_chain_elements(size_t maxElements)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_set_max_chain_elements(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);
  {
    try {
      (arg1)->setMaxChainElements(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.set_number_of_chains

  call-seq:
    set_number_of_chains(size_t numChains)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_set_number_of_chains(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);
  {
    try {
      (arg1)->setNumberOfChains(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.clear_chain

  call-seq:
    clear_chain(size_t chainIndex)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_clear_chain(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);
  {
    try {
      (arg1)->clearChain(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.set_initial_colour

  call-seq:
    set_initial_colour(size_t chainIndex, ColourValue col)
    set_initial_colour(size_t chainIndex, Real r, Real g, Real b, Real a=1.0)
    set_initial_colour(size_t chainIndex, Real r, Real g, Real b)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_set_initial_colour__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);
  {
    try {
      (arg1)->setInitialColour(arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_set_initial_colour__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);
  {
    try {
      (arg1)->setInitialColour(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_set_initial_colour__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);
  {
    try {
      (arg1)->setInitialColour(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RibbonTrail_set_initial_colour(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_set_initial_colour__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_set_initial_colour__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_set_initial_colour__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "RibbonTrail.set_initial_colour", 
    "    void RibbonTrail.set_initial_colour(size_t chainIndex, Ogre::ColourValue const &col)\n"
    "    void RibbonTrail.set_initial_colour(size_t chainIndex, Ogre::Real r, Ogre::Real g, Ogre::Real b, Ogre::Real a)\n"
    "    void RibbonTrail.set_initial_colour(size_t chainIndex, Ogre::Real r, Ogre::Real g, Ogre::Real b)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.get_initial_colour

  call-seq:
    get_initial_colour(size_t chainIndex) -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_get_initial_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::RibbonTrail const *)arg1)->getInitialColour(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.set_colour_change

  call-seq:
    set_colour_change(size_t chainIndex, ColourValue valuePerSecond)
    set_colour_change(size_t chainIndex, Real r, Real g, Real b, Real a)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_set_colour_change__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);
  {
    try {
      (arg1)->setColourChange(arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.set_initial_width

  call-seq:
    set_initial_width(size_t chainIndex, Real width)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_set_initial_width(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);
  {
    try {
      (arg1)->setInitialWidth(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.get_initial_width

  call-seq:
    get_initial_width(size_t chainIndex) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_get_initial_width(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);
  {
    try {
      result = (Ogre::Real)((Ogre::RibbonTrail const *)arg1)->getInitialWidth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.set_width_change

  call-seq:
    set_width_change(size_t chainIndex, Real widthDeltaPerSecond)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_set_width_change(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);
  {
    try {
      (arg1)->setWidthChange(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.get_width_change

  call-seq:
    get_width_change(size_t chainIndex) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_get_width_change(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);
  {
    try {
      result = (Ogre::Real)((Ogre::RibbonTrail const *)arg1)->getWidthChange(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.set_colour_change

  call-seq:
    set_colour_change(size_t chainIndex, ColourValue valuePerSecond)
    set_colour_change(size_t chainIndex, Real r, Real g, Real b, Real a)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_set_colour_change__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);
  {
    try {
      (arg1)->setColourChange(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RibbonTrail_set_colour_change(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_set_colour_change__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_set_colour_change__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "RibbonTrail.set_colour_change", 
    "    void RibbonTrail.set_colour_change(size_t chainIndex, Ogre::ColourValue const &valuePerSecond)\n"
    "    void RibbonTrail.set_colour_change(size_t chainIndex, Ogre::Real r, Ogre::Real g, Ogre::Real b, Ogre::Real a)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.get_colour_change

  call-seq:
    get_colour_change(size_t chainIndex) -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_get_colour_change(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::RibbonTrail const *)arg1)->getColourChange(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.node_updated

  call-seq:
    node_updated(Node node)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_node_updated(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);
  {
    try {
      (arg1)->nodeUpdated((Ogre::Node const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.node_destroyed

  call-seq:
    node_destroyed(Node node)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_node_destroyed(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);
  {
    try {
      (arg1)->nodeDestroyed((Ogre::Node const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail._time_update

  call-seq:
    _time_update(Real time)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail__time_update(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);
  {
    try {
      (arg1)->_timeUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.get_movable_type

  call-seq:
    get_movable_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrail_get_movable_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::RibbonTrail const *)arg1)->getMovableType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrail.cast

  call-seq:
    cast(VALUE value) -> RibbonTrail

A class method.

*/
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];
  {
    try {
      result = (Ogre::RibbonTrail *)Ogre_RibbonTrail_cast(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RibbonTrail, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RibbonTrailFactory < Ogre::Ogre::MovableObjectFactory

  Proxy of C++ Ogre::RibbonTrailFactory class


*/
swig_class SwigClassRibbonTrailFactory;

SWIGINTERN void
free_Ogre_RibbonTrailFactory(Ogre::RibbonTrailFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RibbonTrailFactory.FACTORY_TYPE_NAME

  call-seq:
    FACTORY_TYPE_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::RibbonTrailFactory.FACTORY_TYPE_NAME=

  call-seq:
    FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::RibbonTrailFactory.RibbonTrailFactory_FACTORY_TYPE_NAME

  call-seq:
    RibbonTrailFactory_FACTORY_TYPE_NAME -> String

Get value of attribute.

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



/*
  Document-method: Ogre::RibbonTrailFactory.RibbonTrailFactory_FACTORY_TYPE_NAME=

  call-seq:
    RibbonTrailFactory_FACTORY_TYPE_NAME=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::RibbonTrailFactory.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrailFactory_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::RibbonTrailFactory const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RibbonTrailFactory.destroy_instance

  call-seq:
    destroy_instance(MovableObject obj)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RibbonTrailFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::SceneNode < Ogre::Ogre::Node

  Proxy of C++ Ogre::SceneNode class


*/
swig_class SwigClassSceneNode;


/*
  Document-method: Ogre::SceneNode.new

  call-seq:
    SceneNode.new(SceneManager creator)
    SceneNode.new(SceneManager creator, String name)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::SceneNode *)new Ogre::SceneNode(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      result = (Ogre::SceneNode *)new Ogre::SceneNode(arg1,(Ogre::String const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::SceneNode.attach_object

  call-seq:
    attach_object(MovableObject obj)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_attach_object(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);
  {
    try {
      (arg1)->attachObject(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.num_attached_objects

  call-seq:
    num_attached_objects -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_num_attached_objects(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);
  {
    try {
      result = (unsigned short)((Ogre::SceneNode const *)arg1)->numAttachedObjects();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.get_attached_object

  call-seq:
    get_attached_object(unsigned short index) -> MovableObject
    get_attached_object(String name) -> MovableObject

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_get_attached_object__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);
  {
    try {
      result = (Ogre::MovableObject *)(arg1)->getAttachedObject(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_get_attached_object__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;
  }
  {
    try {
      result = (Ogre::MovableObject *)(arg1)->getAttachedObject((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_get_attached_object(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_get_attached_object__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_get_attached_object__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneNode.get_attached_object", 
    "    Ogre::MovableObject * SceneNode.get_attached_object(unsigned short index)\n"
    "    Ogre::MovableObject * SceneNode.get_attached_object(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.detach_object

  call-seq:
    detach_object(unsigned short index) -> MovableObject
    detach_object(MovableObject obj)
    detach_object(String name) -> MovableObject

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_detach_object__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);
  {
    try {
      result = (Ogre::MovableObject *)(arg1)->detachObject(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_detach_object__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);
  {
    try {
      (arg1)->detachObject(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_detach_object__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;
  }
  {
    try {
      result = (Ogre::MovableObject *)(arg1)->detachObject((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_detach_object(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_detach_object__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_detach_object__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_detach_object__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneNode.detach_object", 
    "    Ogre::MovableObject * SceneNode.detach_object(unsigned short index)\n"
    "    Ogre::MovableObject * SceneNode.detach_object(Ogre::MovableObject *obj)\n"
    "    Ogre::MovableObject * SceneNode.detach_object(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.detach_all_objects

  call-seq:
    detach_all_objects

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_detach_all_objects(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);
  {
    try {
      (arg1)->detachAllObjects();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.is_in_scene_graph

  call-seq:
    is_in_scene_graph -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_is_in_scene_graph(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);
  {
    try {
      result = (bool)((Ogre::SceneNode const *)arg1)->isInSceneGraph();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode._notify_root_node

  call-seq:
    _notify_root_node

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode__notify_root_node(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);
  {
    try {
      (arg1)->_notifyRootNode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode._update

  call-seq:
    _update(bool updateChildren, bool parentHasChanged)

An instance method.

*/
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);
  {
    try {
      (arg1)->_update(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode._update_bounds

  call-seq:
    _update_bounds

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode__update_bounds(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);
  {
    try {
      (arg1)->_updateBounds();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode._find_visible_objects

  call-seq:
    _find_visible_objects(Camera cam, RenderQueue queue, VisibleObjectsBoundsInfo visibleBounds, 
    bool includeChildren=true, 
    bool displayNodes=false, bool onlyShadowCasters=false)
    _find_visible_objects(Camera cam, RenderQueue queue, VisibleObjectsBoundsInfo visibleBounds, 
    bool includeChildren=true, 
    bool displayNodes=false)
    _find_visible_objects(Camera cam, RenderQueue queue, VisibleObjectsBoundsInfo visibleBounds, 
    bool includeChildren=true)
    _find_visible_objects(Camera cam, RenderQueue queue, VisibleObjectsBoundsInfo visibleBounds)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode__find_visible_objects__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);
  {
    try {
      (arg1)->_findVisibleObjects(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__find_visible_objects__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);
  {
    try {
      (arg1)->_findVisibleObjects(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__find_visible_objects__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);
  {
    try {
      (arg1)->_findVisibleObjects(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__find_visible_objects__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);
  {
    try {
      (arg1)->_findVisibleObjects(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode__find_visible_objects(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__find_visible_objects__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__find_visible_objects__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__find_visible_objects__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__find_visible_objects__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "SceneNode._find_visible_objects", 
    "    void SceneNode._find_visible_objects(Ogre::Camera *cam, Ogre::RenderQueue *queue, Ogre::VisibleObjectsBoundsInfo *visibleBounds, bool includeChildren, bool displayNodes, bool onlyShadowCasters)\n"
    "    void SceneNode._find_visible_objects(Ogre::Camera *cam, Ogre::RenderQueue *queue, Ogre::VisibleObjectsBoundsInfo *visibleBounds, bool includeChildren, bool displayNodes)\n"
    "    void SceneNode._find_visible_objects(Ogre::Camera *cam, Ogre::RenderQueue *queue, Ogre::VisibleObjectsBoundsInfo *visibleBounds, bool includeChildren)\n"
    "    void SceneNode._find_visible_objects(Ogre::Camera *cam, Ogre::RenderQueue *queue, Ogre::VisibleObjectsBoundsInfo *visibleBounds)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode._get_world_aabb

  call-seq:
    _get_world_aabb -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode__get_world_aabb(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::SceneNode const *)arg1)->_getWorldAABB();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.get_creator

  call-seq:
    get_creator -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_get_creator(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);
  {
    try {
      result = (Ogre::SceneManager *)((Ogre::SceneNode const *)arg1)->getCreator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.remove_and_destroy_child

  call-seq:
    remove_and_destroy_child(String name)
    remove_and_destroy_child(unsigned short index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_remove_and_destroy_child__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;
  }
  {
    try {
      (arg1)->removeAndDestroyChild((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_remove_and_destroy_child__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);
  {
    try {
      (arg1)->removeAndDestroyChild(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_remove_and_destroy_child(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_remove_and_destroy_child__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_remove_and_destroy_child__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneNode.remove_and_destroy_child", 
    "    void SceneNode.remove_and_destroy_child(Ogre::String const &name)\n"
    "    void SceneNode.remove_and_destroy_child(unsigned short index)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.remove_and_destroy_all_children

  call-seq:
    remove_and_destroy_all_children

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_remove_and_destroy_all_children(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);
  {
    try {
      (arg1)->removeAndDestroyAllChildren();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.show_bounding_box

  call-seq:
    show_bounding_box(bool bShow)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_show_bounding_box(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);
  {
    try {
      (arg1)->showBoundingBox(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.hide_bounding_box

  call-seq:
    hide_bounding_box(bool bHide)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_hide_bounding_box(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);
  {
    try {
      (arg1)->hideBoundingBox(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode._add_bounding_box_to_queue

  call-seq:
    _add_bounding_box_to_queue(RenderQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode__add_bounding_box_to_queue(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);
  {
    try {
      (arg1)->_addBoundingBoxToQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.get_show_bounding_box

  call-seq:
    get_show_bounding_box -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_get_show_bounding_box(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);
  {
    try {
      result = (bool)((Ogre::SceneNode const *)arg1)->getShowBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.create_child_scene_node

  call-seq:
    create_child_scene_node(Vector3 translate=, Quaternion rotate=IDENTITY) -> SceneNode
    create_child_scene_node(Vector3 translate=) -> SceneNode
    create_child_scene_node -> SceneNode
    create_child_scene_node(String name, Vector3 translate=, Quaternion rotate=IDENTITY) -> SceneNode
    create_child_scene_node(String name, Vector3 translate=) -> SceneNode
    create_child_scene_node(String name) -> SceneNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_create_child_scene_node__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);
  {
    try {
      result = (Ogre::SceneNode *)(arg1)->createChildSceneNode((Ogre::Vector3 const &)*arg2,(Ogre::Quaternion const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_create_child_scene_node__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);
  {
    try {
      result = (Ogre::SceneNode *)(arg1)->createChildSceneNode((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_create_child_scene_node__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);
  {
    try {
      result = (Ogre::SceneNode *)(arg1)->createChildSceneNode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_create_child_scene_node__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);
  {
    try {
      result = (Ogre::SceneNode *)(arg1)->createChildSceneNode((Ogre::String const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_child_scene_node__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);
  {
    try {
      result = (Ogre::SceneNode *)(arg1)->createChildSceneNode((Ogre::String const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_child_scene_node__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;
  }
  {
    try {
      result = (Ogre::SceneNode *)(arg1)->createChildSceneNode((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_child_scene_node(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_create_child_scene_node__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_create_child_scene_node__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_create_child_scene_node__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_create_child_scene_node__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_create_child_scene_node__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_create_child_scene_node__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneNode.create_child_scene_node", 
    "    Ogre::SceneNode * SceneNode.create_child_scene_node(Ogre::Vector3 const &translate, Ogre::Quaternion const &rotate)\n"
    "    Ogre::SceneNode * SceneNode.create_child_scene_node(Ogre::Vector3 const &translate)\n"
    "    Ogre::SceneNode * SceneNode.create_child_scene_node()\n"
    "    Ogre::SceneNode * SceneNode.create_child_scene_node(Ogre::String const &name, Ogre::Vector3 const &translate, Ogre::Quaternion const &rotate)\n"
    "    Ogre::SceneNode * SceneNode.create_child_scene_node(Ogre::String const &name, Ogre::Vector3 const &translate)\n"
    "    Ogre::SceneNode * SceneNode.create_child_scene_node(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.find_lights

  call-seq:
    find_lights(LightList destList, Real radius, uint32 lightMask=0xFFFFFFFF)
    find_lights(LightList destList, Real radius)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_find_lights__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);
  {
    try {
      ((Ogre::SceneNode const *)arg1)->findLights(*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_find_lights__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);
  {
    try {
      ((Ogre::SceneNode const *)arg1)->findLights(*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_find_lights(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_find_lights__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_find_lights__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneNode.find_lights", 
    "    void SceneNode.find_lights(Ogre::LightList &destList, Ogre::Real radius, Ogre::uint32 lightMask)\n"
    "    void SceneNode.find_lights(Ogre::LightList &destList, Ogre::Real radius)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.set_fixed_yaw_axis

  call-seq:
    set_fixed_yaw_axis(bool useFixed, Vector3 fixedAxis=UNIT_Y)
    set_fixed_yaw_axis(bool useFixed)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_set_fixed_yaw_axis__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);
  {
    try {
      (arg1)->setFixedYawAxis(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_set_fixed_yaw_axis__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);
  {
    try {
      (arg1)->setFixedYawAxis(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_set_fixed_yaw_axis(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_set_fixed_yaw_axis__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_set_fixed_yaw_axis__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneNode.set_fixed_yaw_axis", 
    "    void SceneNode.set_fixed_yaw_axis(bool useFixed, Ogre::Vector3 const &fixedAxis)\n"
    "    void SceneNode.set_fixed_yaw_axis(bool useFixed)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.yaw

  call-seq:
    yaw(Radian angle, TransformSpace relativeTo=TS_LOCAL)
    yaw(Radian angle)

An instance method.

*/
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);
  {
    try {
      (arg1)->yaw((Ogre::Radian const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->yaw((Ogre::Radian const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::SceneNode.set_direction

  call-seq:
    set_direction(Real x, Real y, Real z, TransformSpace relativeTo=TS_LOCAL, 
    Vector3 localDirectionVector=NEGATIVE_UNIT_Z)
    set_direction(Real x, Real y, Real z, TransformSpace relativeTo=TS_LOCAL)
    set_direction(Real x, Real y, Real z)
    set_direction(Vector3 vec, TransformSpace relativeTo=TS_LOCAL, Vector3 localDirectionVector=NEGATIVE_UNIT_Z)
    set_direction(Vector3 vec, TransformSpace relativeTo=TS_LOCAL)
    set_direction(Vector3 vec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_set_direction__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);
  {
    try {
      (arg1)->setDirection(arg2,arg3,arg4,arg5,(Ogre::Vector3 const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_set_direction__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);
  {
    try {
      (arg1)->setDirection(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_set_direction__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);
  {
    try {
      (arg1)->setDirection(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_set_direction__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);
  {
    try {
      (arg1)->setDirection((Ogre::Vector3 const &)*arg2,arg3,(Ogre::Vector3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_set_direction__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);
  {
    try {
      (arg1)->setDirection((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_set_direction__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);
  {
    try {
      (arg1)->setDirection((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_set_direction(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_set_direction__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_set_direction__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_set_direction__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_set_direction__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_set_direction__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_set_direction__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "SceneNode.set_direction", 
    "    void SceneNode.set_direction(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Node::TransformSpace relativeTo, Ogre::Vector3 const &localDirectionVector)\n"
    "    void SceneNode.set_direction(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Node::TransformSpace relativeTo)\n"
    "    void SceneNode.set_direction(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    void SceneNode.set_direction(Ogre::Vector3 const &vec, Ogre::Node::TransformSpace relativeTo, Ogre::Vector3 const &localDirectionVector)\n"
    "    void SceneNode.set_direction(Ogre::Vector3 const &vec, Ogre::Node::TransformSpace relativeTo)\n"
    "    void SceneNode.set_direction(Ogre::Vector3 const &vec)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.look_at

  call-seq:
    look_at(Vector3 targetPoint, TransformSpace relativeTo, Vector3 localDirectionVector=NEGATIVE_UNIT_Z)
    look_at(Vector3 targetPoint, TransformSpace relativeTo)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_look_at__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);
  {
    try {
      (arg1)->lookAt((Ogre::Vector3 const &)*arg2,arg3,(Ogre::Vector3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_look_at__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);
  {
    try {
      (arg1)->lookAt((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_look_at(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_look_at__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_look_at__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneNode.look_at", 
    "    void SceneNode.look_at(Ogre::Vector3 const &targetPoint, Ogre::Node::TransformSpace relativeTo, Ogre::Vector3 const &localDirectionVector)\n"
    "    void SceneNode.look_at(Ogre::Vector3 const &targetPoint, Ogre::Node::TransformSpace relativeTo)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.set_auto_tracking

  call-seq:
    set_auto_tracking(bool enabled, SceneNode target=0, Vector3 localDirectionVector=NEGATIVE_UNIT_Z, 
    Vector3 offset=)
    set_auto_tracking(bool enabled, SceneNode target=0, Vector3 localDirectionVector=NEGATIVE_UNIT_Z)
    set_auto_tracking(bool enabled, SceneNode target=0)
    set_auto_tracking(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_set_auto_tracking__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);
  {
    try {
      (arg1)->setAutoTracking(arg2,arg3,(Ogre::Vector3 const &)*arg4,(Ogre::Vector3 const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_set_auto_tracking__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);
  {
    try {
      (arg1)->setAutoTracking(arg2,arg3,(Ogre::Vector3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_set_auto_tracking__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);
  {
    try {
      (arg1)->setAutoTracking(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_set_auto_tracking__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);
  {
    try {
      (arg1)->setAutoTracking(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_set_auto_tracking(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_set_auto_tracking__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_set_auto_tracking__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_set_auto_tracking__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_set_auto_tracking__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "SceneNode.set_auto_tracking", 
    "    void SceneNode.set_auto_tracking(bool enabled, Ogre::SceneNode *const target, Ogre::Vector3 const &localDirectionVector, Ogre::Vector3 const &offset)\n"
    "    void SceneNode.set_auto_tracking(bool enabled, Ogre::SceneNode *const target, Ogre::Vector3 const &localDirectionVector)\n"
    "    void SceneNode.set_auto_tracking(bool enabled, Ogre::SceneNode *const target)\n"
    "    void SceneNode.set_auto_tracking(bool enabled)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.get_auto_track_target

  call-seq:
    get_auto_track_target -> SceneNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_get_auto_track_target(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);
  {
    try {
      result = (Ogre::SceneNode *)(arg1)->getAutoTrackTarget();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.get_auto_track_offset

  call-seq:
    get_auto_track_offset -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_get_auto_track_offset(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);
  {
    try {
      result = (Ogre::Vector3 *) &(arg1)->getAutoTrackOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.get_auto_track_local_direction

  call-seq:
    get_auto_track_local_direction -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_get_auto_track_local_direction(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);
  {
    try {
      result = (Ogre::Vector3 *) &(arg1)->getAutoTrackLocalDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode._auto_track

  call-seq:
    _auto_track

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode__auto_track(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);
  {
    try {
      (arg1)->_autoTrack();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.get_parent_scene_node

  call-seq:
    get_parent_scene_node -> SceneNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_get_parent_scene_node(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);
  {
    try {
      result = (Ogre::SceneNode *)((Ogre::SceneNode const *)arg1)->getParentSceneNode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.set_visible

  call-seq:
    set_visible(bool visible, bool cascade=true)
    set_visible(bool visible)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_set_visible__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);
  {
    try {
      (arg1)->setVisible(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_set_visible__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);
  {
    try {
      (arg1)->setVisible(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_set_visible(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_set_visible__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_set_visible__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneNode.set_visible", 
    "    void SceneNode.set_visible(bool visible, bool cascade)\n"
    "    void SceneNode.set_visible(bool visible)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.flip_visibility

  call-seq:
    flip_visibility(bool cascade=true)
    flip_visibility

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_flip_visibility__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);
  {
    try {
      (arg1)->flipVisibility(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_flip_visibility__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);
  {
    try {
      (arg1)->flipVisibility();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_flip_visibility(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_flip_visibility__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_flip_visibility__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneNode.flip_visibility", 
    "    void SceneNode.flip_visibility(bool cascade)\n"
    "    void SceneNode.flip_visibility()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.set_debug_display_enabled

  call-seq:
    set_debug_display_enabled(bool enabled, bool cascade=true)
    set_debug_display_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_set_debug_display_enabled__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);
  {
    try {
      (arg1)->setDebugDisplayEnabled(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_set_debug_display_enabled__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);
  {
    try {
      (arg1)->setDebugDisplayEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_set_debug_display_enabled(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_set_debug_display_enabled__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_set_debug_display_enabled__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneNode.set_debug_display_enabled", 
    "    void SceneNode.set_debug_display_enabled(bool enabled, bool cascade)\n"
    "    void SceneNode.set_debug_display_enabled(bool enabled)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneNode.get_debug_renderable

  call-seq:
    get_debug_renderable -> DebugRenderable

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneNode_get_debug_renderable(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);
  {
    try {
      result = (Ogre::Node::DebugRenderable *)(arg1)->getDebugRenderable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node__DebugRenderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::SceneQuery

  Proxy of C++ Ogre::SceneQuery class


*/
swig_class SwigClassSceneQuery;


/*
  Document-method: Ogre::WorldFragmentType.WFT_NONE

  call-seq:
    WFT_NONE -> int

A class method.

*/

/*
  Document-method: Ogre::WorldFragmentType.WFT_PLANE_BOUNDED_REGION

  call-seq:
    WFT_PLANE_BOUNDED_REGION -> int

A class method.

*/

/*
  Document-method: Ogre::WorldFragmentType.WFT_SINGLE_INTERSECTION

  call-seq:
    WFT_SINGLE_INTERSECTION -> int

A class method.

*/

/*
  Document-method: Ogre::WorldFragmentType.WFT_CUSTOM_GEOMETRY

  call-seq:
    WFT_CUSTOM_GEOMETRY -> int

A class method.

*/

/*
  Document-method: Ogre::WorldFragmentType.WFT_RENDER_OPERATION

  call-seq:
    WFT_RENDER_OPERATION -> int

A class method.

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


/*
  Document-method: Ogre::SceneQuery.new

  call-seq:
    SceneQuery.new(SceneManager mgr)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::SceneQuery *)new Ogre::SceneQuery(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SceneQuery(Ogre::SceneQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SceneQuery.set_query_mask

  call-seq:
    set_query_mask(uint32 mask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneQuery_set_query_mask(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);
  {
    try {
      (arg1)->setQueryMask(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneQuery.get_query_mask

  call-seq:
    get_query_mask -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneQuery_get_query_mask(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::SceneQuery const *)arg1)->getQueryMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneQuery.set_query_type_mask

  call-seq:
    set_query_type_mask(uint32 mask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneQuery_set_query_type_mask(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);
  {
    try {
      (arg1)->setQueryTypeMask(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneQuery.get_query_type_mask

  call-seq:
    get_query_type_mask -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneQuery_get_query_type_mask(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::SceneQuery const *)arg1)->getQueryTypeMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneQuery.set_world_fragment_type

  call-seq:
    set_world_fragment_type(enum Ogre::SceneQuery::WorldFragmentType wft)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneQuery_set_world_fragment_type(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);
  {
    try {
      (arg1)->setWorldFragmentType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneQuery.get_world_fragment_type

  call-seq:
    get_world_fragment_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneQuery_get_world_fragment_type(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);
  {
    try {
      result = (Ogre::SceneQuery::WorldFragmentType)((Ogre::SceneQuery const *)arg1)->getWorldFragmentType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneQuery.get_supported_world_fragment_types

  call-seq:
    get_supported_world_fragment_types -> Ogre::set<(Ogre::SceneQuery::WorldFragmentType,std::less<(Ogre::SceneQuery::WorldFragmentType)>,Ogre::STLAllocator<(Ogre::SceneQuery::WorldFragmentType,Ogre::GeneralAllocPolicy)>)>::type

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneQuery_get_supported_world_fragment_types(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);
  {
    try {
      result = (Ogre::set< Ogre::SceneQuery::WorldFragmentType,std::less< Ogre::SceneQuery::WorldFragmentType >,Ogre::STLAllocator< Ogre::SceneQuery::WorldFragmentType,Ogre::GeneralAllocPolicy > >::type *)((Ogre::SceneQuery const *)arg1)->getSupportedWorldFragmentTypes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-class: Ogre::SceneQueryListener

  Proxy of C++ Ogre::SceneQueryListener class


*/
swig_class SwigClassSceneQueryListener;

SWIGINTERN void
free_Ogre_SceneQueryListener(Ogre::SceneQueryListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SceneQueryListener.query_result

  call-seq:
    query_result(MovableObject object) -> bool
    query_result(WorldFragment fragment) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneQueryListener_query_result__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);
  {
    try {
      result = (bool)(arg1)->queryResult(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneQueryListener_query_result__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);
  {
    try {
      result = (bool)(arg1)->queryResult(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneQueryListener_query_result(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_query_result__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_query_result__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneQueryListener.query_result", 
    "    bool SceneQueryListener.query_result(Ogre::MovableObject *object)\n"
    "    bool SceneQueryListener.query_result(Ogre::SceneQuery::WorldFragment *fragment)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::SceneQueryResult

  Proxy of C++ Ogre::SceneQueryResult class


*/
swig_class SwigClassSceneQueryResult;


/*
  Document-method: Ogre::SceneQueryResult.movables

  call-seq:
    movables -> SceneQueryResultMovableList

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneQueryResult.movables=

  call-seq:
    movables=(x) -> SceneQueryResultMovableList

Set new value for attribute.

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



/*
  Document-method: Ogre::SceneQueryResult.worldFragments

  call-seq:
    worldFragments -> SceneQueryResultWorldFragmentList

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneQueryResult.worldFragments=

  call-seq:
    worldFragments=(x) -> SceneQueryResultWorldFragmentList

Set new value for attribute.

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


/*
  Document-method: Ogre::SceneQueryResult.new

  call-seq:
    SceneQueryResult.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SceneQueryResult *)new Ogre::SceneQueryResult();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SceneQueryResult(Ogre::SceneQueryResult *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::RegionSceneQuery < Ogre::Ogre::SceneQuery, Ogre::Ogre::SceneQueryListener

  Proxy of C++ Ogre::RegionSceneQuery class


*/
swig_class SwigClassRegionSceneQuery;

SWIGINTERN void
free_Ogre_RegionSceneQuery(Ogre::RegionSceneQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RegionSceneQuery.execute

  call-seq:
    execute -> SceneQueryResult
    execute(SceneQueryListener listener)

An instance method.

*/
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);
  {
    try {
      result = (Ogre::SceneQueryResult *) &(arg1)->execute();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      (arg1)->execute(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::RegionSceneQuery.get_last_results

  call-seq:
    get_last_results -> SceneQueryResult

An instance method.

*/
SWIGINTERN VALUE
_wrap_RegionSceneQuery_get_last_results(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);
  {
    try {
      result = (Ogre::SceneQueryResult *) &((Ogre::RegionSceneQuery const *)arg1)->getLastResults();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneQueryResult, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RegionSceneQuery.clear_results

  call-seq:
    clear_results

An instance method.

*/
SWIGINTERN VALUE
_wrap_RegionSceneQuery_clear_results(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);
  {
    try {
      (arg1)->clearResults();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RegionSceneQuery.query_result

  call-seq:
    query_result(MovableObject first) -> bool
    query_result(WorldFragment fragment) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RegionSceneQuery_query_result__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);
  {
    try {
      result = (bool)(arg1)->queryResult(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RegionSceneQuery_query_result__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);
  {
    try {
      result = (bool)(arg1)->queryResult(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RegionSceneQuery_query_result(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_query_result__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_query_result__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RegionSceneQuery.query_result", 
    "    bool RegionSceneQuery.query_result(Ogre::MovableObject *first)\n"
    "    bool RegionSceneQuery.query_result(Ogre::SceneQuery::WorldFragment *fragment)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::AxisAlignedBoxSceneQuery < Ogre::Ogre::RegionSceneQuery

  Proxy of C++ Ogre::AxisAlignedBoxSceneQuery class


*/
swig_class SwigClassAxisAlignedBoxSceneQuery;

SWIGINTERN void
free_Ogre_AxisAlignedBoxSceneQuery(Ogre::AxisAlignedBoxSceneQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::AxisAlignedBoxSceneQuery.set_box

  call-seq:
    set_box(AxisAlignedBox box)

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBoxSceneQuery_set_box(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);
  {
    try {
      (arg1)->setBox((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBoxSceneQuery.get_box

  call-seq:
    get_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_AxisAlignedBoxSceneQuery_get_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::AxisAlignedBoxSceneQuery const *)arg1)->getBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::SphereSceneQuery < Ogre::Ogre::RegionSceneQuery

  Proxy of C++ Ogre::SphereSceneQuery class


*/
swig_class SwigClassSphereSceneQuery;

SWIGINTERN void
free_Ogre_SphereSceneQuery(Ogre::SphereSceneQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SphereSceneQuery.set_sphere

  call-seq:
    set_sphere(Sphere sphere)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SphereSceneQuery_set_sphere(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);
  {
    try {
      (arg1)->setSphere((Ogre::Sphere const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SphereSceneQuery.get_sphere

  call-seq:
    get_sphere -> Sphere

An instance method.

*/
SWIGINTERN VALUE
_wrap_SphereSceneQuery_get_sphere(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);
  {
    try {
      result = (Ogre::Sphere *) &((Ogre::SphereSceneQuery const *)arg1)->getSphere();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PlaneBoundedVolumeListSceneQuery < Ogre::Ogre::RegionSceneQuery

  Proxy of C++ Ogre::PlaneBoundedVolumeListSceneQuery class


*/
swig_class SwigClassPlaneBoundedVolumeListSceneQuery;

SWIGINTERN void
free_Ogre_PlaneBoundedVolumeListSceneQuery(Ogre::PlaneBoundedVolumeListSceneQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PlaneBoundedVolumeListSceneQuery.set_volumes

  call-seq:
    set_volumes(PlaneBoundedVolumeList volumes)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PlaneBoundedVolumeListSceneQuery_set_volumes(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);
  {
    try {
      (arg1)->setVolumes((Ogre::PlaneBoundedVolumeList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PlaneBoundedVolumeListSceneQuery.get_volumes

  call-seq:
    get_volumes -> PlaneBoundedVolumeList

An instance method.

*/
SWIGINTERN VALUE
_wrap_PlaneBoundedVolumeListSceneQuery_get_volumes(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);
  {
    try {
      result = (Ogre::PlaneBoundedVolumeList *) &((Ogre::PlaneBoundedVolumeListSceneQuery const *)arg1)->getVolumes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::RaySceneQueryListener

  Proxy of C++ Ogre::RaySceneQueryListener class


*/
swig_class SwigClassRaySceneQueryListener;

SWIGINTERN void
free_Ogre_RaySceneQueryListener(Ogre::RaySceneQueryListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RaySceneQueryListener.query_result

  call-seq:
    query_result(MovableObject obj, Real distance) -> bool
    query_result(WorldFragment fragment, Real distance) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RaySceneQueryListener_query_result__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);
  {
    try {
      result = (bool)(arg1)->queryResult(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQueryListener_query_result__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);
  {
    try {
      result = (bool)(arg1)->queryResult(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RaySceneQueryListener_query_result(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_query_result__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_query_result__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RaySceneQueryListener.query_result", 
    "    bool RaySceneQueryListener.query_result(Ogre::MovableObject *obj, Ogre::Real distance)\n"
    "    bool RaySceneQueryListener.query_result(Ogre::SceneQuery::WorldFragment *fragment, Ogre::Real distance)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::RaySceneQueryResultEntry

  Proxy of C++ Ogre::RaySceneQueryResultEntry class


*/
swig_class SwigClassRaySceneQueryResultEntry;


/*
  Document-method: Ogre::RaySceneQueryResultEntry.distance

  call-seq:
    distance -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::RaySceneQueryResultEntry.distance=

  call-seq:
    distance=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::RaySceneQueryResultEntry.movable

  call-seq:
    movable -> MovableObject

Get value of attribute.

*/

/*
  Document-method: Ogre::RaySceneQueryResultEntry.movable=

  call-seq:
    movable=(x) -> MovableObject

Set new value for attribute.

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



/*
  Document-method: Ogre::RaySceneQueryResultEntry.worldFragment

  call-seq:
    worldFragment -> WorldFragment

Get value of attribute.

*/

/*
  Document-method: Ogre::RaySceneQueryResultEntry.worldFragment=

  call-seq:
    worldFragment=(x) -> WorldFragment

Set new value for attribute.

*/
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);
  {
    try {
      result = (bool)((Ogre::RaySceneQueryResultEntry const *)arg1)->operator <((Ogre::RaySceneQueryResultEntry const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::RaySceneQueryResultEntry.new

  call-seq:
    RaySceneQueryResultEntry.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::RaySceneQueryResultEntry *)new Ogre::RaySceneQueryResultEntry();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RaySceneQueryResultEntry(Ogre::RaySceneQueryResultEntry *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::RaySceneQuery < Ogre::Ogre::SceneQuery, Ogre::Ogre::RaySceneQueryListener

  Proxy of C++ Ogre::RaySceneQuery class


*/
swig_class SwigClassRaySceneQuery;

SWIGINTERN void
free_Ogre_RaySceneQuery(Ogre::RaySceneQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RaySceneQuery.set_ray

  call-seq:
    set_ray(Ray ray)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RaySceneQuery_set_ray(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);
  {
    try {
      (arg1)->setRay((Ogre::Ray const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RaySceneQuery.get_ray

  call-seq:
    get_ray -> Ray

An instance method.

*/
SWIGINTERN VALUE
_wrap_RaySceneQuery_get_ray(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);
  {
    try {
      result = (Ogre::Ray *) &((Ogre::RaySceneQuery const *)arg1)->getRay();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Ray, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RaySceneQuery.set_sort_by_distance

  call-seq:
    set_sort_by_distance(bool sort, ushort maxresults=0)
    set_sort_by_distance(bool sort)

An instance method.

*/
SWIGINTERN VALUE
_wrap_RaySceneQuery_set_sort_by_distance__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);
  {
    try {
      (arg1)->setSortByDistance(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_set_sort_by_distance__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);
  {
    try {
      (arg1)->setSortByDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RaySceneQuery_set_sort_by_distance(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_set_sort_by_distance__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_set_sort_by_distance__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RaySceneQuery.set_sort_by_distance", 
    "    void RaySceneQuery.set_sort_by_distance(bool sort, Ogre::ushort maxresults)\n"
    "    void RaySceneQuery.set_sort_by_distance(bool sort)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RaySceneQuery.get_sort_by_distance

  call-seq:
    get_sort_by_distance -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RaySceneQuery_get_sort_by_distance(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);
  {
    try {
      result = (bool)((Ogre::RaySceneQuery const *)arg1)->getSortByDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RaySceneQuery.get_max_results

  call-seq:
    get_max_results -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_RaySceneQuery_get_max_results(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::RaySceneQuery const *)arg1)->getMaxResults();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RaySceneQuery.execute

  call-seq:
    execute -> RaySceneQueryResult
    execute(RaySceneQueryListener listener)

An instance method.

*/
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);
  {
    try {
      result = (Ogre::RaySceneQueryResult *) &(arg1)->execute();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      (arg1)->execute(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::RaySceneQuery.get_last_results

  call-seq:
    get_last_results -> RaySceneQueryResult

An instance method.

*/
SWIGINTERN VALUE
_wrap_RaySceneQuery_get_last_results(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);
  {
    try {
      result = (Ogre::RaySceneQueryResult *) &(arg1)->getLastResults();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__RaySceneQueryResultEntry_Ogre__STLAllocatorT_Ogre__RaySceneQueryResultEntry_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RaySceneQuery.clear_results

  call-seq:
    clear_results

An instance method.

*/
SWIGINTERN VALUE
_wrap_RaySceneQuery_clear_results(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);
  {
    try {
      (arg1)->clearResults();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RaySceneQuery.query_result

  call-seq:
    query_result(MovableObject obj, Real distance) -> bool
    query_result(WorldFragment fragment, Real distance) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_RaySceneQuery_query_result__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);
  {
    try {
      result = (bool)(arg1)->queryResult(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_query_result__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);
  {
    try {
      result = (bool)(arg1)->queryResult(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RaySceneQuery_query_result(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_query_result__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_query_result__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RaySceneQuery.query_result", 
    "    bool RaySceneQuery.query_result(Ogre::MovableObject *obj, Ogre::Real distance)\n"
    "    bool RaySceneQuery.query_result(Ogre::SceneQuery::WorldFragment *fragment, Ogre::Real distance)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::IntersectionSceneQueryListener

  Proxy of C++ Ogre::IntersectionSceneQueryListener class


*/
swig_class SwigClassIntersectionSceneQueryListener;

SWIGINTERN void
free_Ogre_IntersectionSceneQueryListener(Ogre::IntersectionSceneQueryListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::IntersectionSceneQueryListener.query_result

  call-seq:
    query_result(MovableObject first, MovableObject second) -> bool
    query_result(MovableObject movable, WorldFragment fragment) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_IntersectionSceneQueryListener_query_result__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);
  {
    try {
      result = (bool)(arg1)->queryResult(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntersectionSceneQueryListener_query_result__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);
  {
    try {
      result = (bool)(arg1)->queryResult(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_IntersectionSceneQueryListener_query_result(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_query_result__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_query_result__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "IntersectionSceneQueryListener.query_result", 
    "    bool IntersectionSceneQueryListener.query_result(Ogre::MovableObject *first, Ogre::MovableObject *second)\n"
    "    bool IntersectionSceneQueryListener.query_result(Ogre::MovableObject *movable, Ogre::SceneQuery::WorldFragment *fragment)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::IntersectionSceneQueryResult

  Proxy of C++ Ogre::IntersectionSceneQueryResult class


*/
swig_class SwigClassIntersectionSceneQueryResult;


/*
  Document-method: Ogre::IntersectionSceneQueryResult.movables2movables

  call-seq:
    movables2movables -> SceneQueryMovableIntersectionList

Get value of attribute.

*/

/*
  Document-method: Ogre::IntersectionSceneQueryResult.movables2movables=

  call-seq:
    movables2movables=(x) -> SceneQueryMovableIntersectionList

Set new value for attribute.

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



/*
  Document-method: Ogre::IntersectionSceneQueryResult.movables2world

  call-seq:
    movables2world -> SceneQueryMovableWorldFragmentIntersectionList

Get value of attribute.

*/

/*
  Document-method: Ogre::IntersectionSceneQueryResult.movables2world=

  call-seq:
    movables2world=(x) -> SceneQueryMovableWorldFragmentIntersectionList

Set new value for attribute.

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


/*
  Document-method: Ogre::IntersectionSceneQueryResult.new

  call-seq:
    IntersectionSceneQueryResult.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::IntersectionSceneQueryResult *)new Ogre::IntersectionSceneQueryResult();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_IntersectionSceneQueryResult(Ogre::IntersectionSceneQueryResult *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::IntersectionSceneQuery < Ogre::Ogre::SceneQuery, Ogre::Ogre::IntersectionSceneQueryListener

  Proxy of C++ Ogre::IntersectionSceneQuery class


*/
swig_class SwigClassIntersectionSceneQuery;

SWIGINTERN void
free_Ogre_IntersectionSceneQuery(Ogre::IntersectionSceneQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::IntersectionSceneQuery.execute

  call-seq:
    execute -> IntersectionSceneQueryResult
    execute(IntersectionSceneQueryListener listener)

An instance method.

*/
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);
  {
    try {
      result = (Ogre::IntersectionSceneQueryResult *) &(arg1)->execute();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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);
  {
    try {
      (arg1)->execute(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::IntersectionSceneQuery.get_last_results

  call-seq:
    get_last_results -> IntersectionSceneQueryResult

An instance method.

*/
SWIGINTERN VALUE
_wrap_IntersectionSceneQuery_get_last_results(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);
  {
    try {
      result = (Ogre::IntersectionSceneQueryResult *) &((Ogre::IntersectionSceneQuery const *)arg1)->getLastResults();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__IntersectionSceneQueryResult, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::IntersectionSceneQuery.clear_results

  call-seq:
    clear_results

An instance method.

*/
SWIGINTERN VALUE
_wrap_IntersectionSceneQuery_clear_results(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);
  {
    try {
      (arg1)->clearResults();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::IntersectionSceneQuery.query_result

  call-seq:
    query_result(MovableObject first, MovableObject second) -> bool
    query_result(MovableObject movable, WorldFragment fragment) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_IntersectionSceneQuery_query_result__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);
  {
    try {
      result = (bool)(arg1)->queryResult(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntersectionSceneQuery_query_result__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);
  {
    try {
      result = (bool)(arg1)->queryResult(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_IntersectionSceneQuery_query_result(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_query_result__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_query_result__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "IntersectionSceneQuery.query_result", 
    "    bool IntersectionSceneQuery.query_result(Ogre::MovableObject *first, Ogre::MovableObject *second)\n"
    "    bool IntersectionSceneQuery.query_result(Ogre::MovableObject *movable, Ogre::SceneQuery::WorldFragment *fragment)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::ShadowTextureConfig

  Proxy of C++ Ogre::ShadowTextureConfig class


*/
swig_class SwigClassShadowTextureConfig;


/*
  Document-method: Ogre::ShadowTextureConfig.width

  call-seq:
    width -> unsigned int

Get value of attribute.

*/

/*
  Document-method: Ogre::ShadowTextureConfig.width=

  call-seq:
    width=(x) -> unsigned int

Set new value for attribute.

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



/*
  Document-method: Ogre::ShadowTextureConfig.height

  call-seq:
    height -> unsigned int

Get value of attribute.

*/

/*
  Document-method: Ogre::ShadowTextureConfig.height=

  call-seq:
    height=(x) -> unsigned int

Set new value for attribute.

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



/*
  Document-method: Ogre::ShadowTextureConfig.format

  call-seq:
    format -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::ShadowTextureConfig.format=

  call-seq:
    format=(x) -> int

Set new value for attribute.

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



/*
  Document-method: Ogre::ShadowTextureConfig.fsaa

  call-seq:
    fsaa -> unsigned int

Get value of attribute.

*/

/*
  Document-method: Ogre::ShadowTextureConfig.fsaa=

  call-seq:
    fsaa=(x) -> unsigned int

Set new value for attribute.

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



/*
  Document-method: Ogre::ShadowTextureConfig.depthBufferPoolId

  call-seq:
    depthBufferPoolId -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::ShadowTextureConfig.depthBufferPoolId=

  call-seq:
    depthBufferPoolId=(x) -> uint16

Set new value for attribute.

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


/*
  Document-method: Ogre::ShadowTextureConfig.new

  call-seq:
    ShadowTextureConfig.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ShadowTextureConfig *)new Ogre::ShadowTextureConfig();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_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);
  {
    try {
      result = (bool)Ogre::operator ==((Ogre::ShadowTextureConfig const &)*arg1,(Ogre::ShadowTextureConfig const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___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;
}



/*
  Document-class: Ogre::ShadowTextureManager

  Proxy of C++ Ogre::ShadowTextureManager class


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


/*
  Document-method: Ogre::ShadowTextureManager.new

  call-seq:
    ShadowTextureManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ShadowTextureManager *)new Ogre::ShadowTextureManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ShadowTextureManager(Ogre::ShadowTextureManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ShadowTextureManager.get_shadow_textures

  call-seq:
    get_shadow_textures(ShadowTextureConfigList config, ShadowTextureList listToPopulate)

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowTextureManager_get_shadow_textures(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);
  {
    try {
      (arg1)->getShadowTextures((Ogre::ShadowTextureConfigList const &)*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowTextureManager.get_null_shadow_texture

  call-seq:
    get_null_shadow_texture(PixelFormat format) -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowTextureManager_get_null_shadow_texture(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);
  {
    try {
      result = (arg1)->getNullShadowTexture(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowTextureManager.clear_unused

  call-seq:
    clear_unused

An instance method.

*/
SWIGINTERN VALUE
_wrap_ShadowTextureManager_clear_unused(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);
  {
    try {
      (arg1)->clearUnused();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowTextureManager.get_singleton

  call-seq:
    get_singleton -> ShadowTextureManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowTextureManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::ShadowTextureManager *) &Ogre::ShadowTextureManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ShadowTextureManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowTextureManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> ShadowTextureManager

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowTextureManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::ShadowTextureManager *)Ogre::ShadowTextureManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ShadowTextureManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ViewPoint

  Proxy of C++ Ogre::ViewPoint class


*/
swig_class SwigClassViewPoint;


/*
  Document-method: Ogre::ViewPoint.position

  call-seq:
    position -> Vector3

Get value of attribute.

*/

/*
  Document-method: Ogre::ViewPoint.position=

  call-seq:
    position=(x) -> Vector3

Set new value for attribute.

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



/*
  Document-method: Ogre::ViewPoint.orientation

  call-seq:
    orientation -> Quaternion

Get value of attribute.

*/

/*
  Document-method: Ogre::ViewPoint.orientation=

  call-seq:
    orientation=(x) -> Quaternion

Set new value for attribute.

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


/*
  Document-method: Ogre::ViewPoint.new

  call-seq:
    ViewPoint.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ViewPoint *)new Ogre::ViewPoint();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ViewPoint(Ogre::ViewPoint *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::VisibleObjectsBoundsInfo

  Proxy of C++ Ogre::VisibleObjectsBoundsInfo class


*/
swig_class SwigClassVisibleObjectsBoundsInfo;


/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.aabb

  call-seq:
    aabb -> AxisAlignedBox

Get value of attribute.

*/

/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.aabb=

  call-seq:
    aabb=(x) -> AxisAlignedBox

Set new value for attribute.

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



/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.receiverAabb

  call-seq:
    receiverAabb -> AxisAlignedBox

Get value of attribute.

*/

/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.receiverAabb=

  call-seq:
    receiverAabb=(x) -> AxisAlignedBox

Set new value for attribute.

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



/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.minDistance

  call-seq:
    minDistance -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.minDistance=

  call-seq:
    minDistance=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.maxDistance

  call-seq:
    maxDistance -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.maxDistance=

  call-seq:
    maxDistance=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.minDistanceInFrustum

  call-seq:
    minDistanceInFrustum -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.minDistanceInFrustum=

  call-seq:
    minDistanceInFrustum=(x) -> Real

Set new value for attribute.

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



/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.maxDistanceInFrustum

  call-seq:
    maxDistanceInFrustum -> Real

Get value of attribute.

*/

/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.maxDistanceInFrustum=

  call-seq:
    maxDistanceInFrustum=(x) -> Real

Set new value for attribute.

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


/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.new

  call-seq:
    VisibleObjectsBoundsInfo.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::VisibleObjectsBoundsInfo *)new Ogre::VisibleObjectsBoundsInfo();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.reset

  call-seq:
    reset

An instance method.

*/
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);
  {
    try {
      (arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.merge

  call-seq:
    merge(AxisAlignedBox boxBounds, Sphere sphereBounds, Camera cam, 
    bool receiver=true)
    merge(AxisAlignedBox boxBounds, Sphere sphereBounds, Camera cam)

An instance method.

*/
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);
  {
    try {
      (arg1)->merge((Ogre::AxisAlignedBox const &)*arg2,(Ogre::Sphere const &)*arg3,(Ogre::Camera const *)arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->merge((Ogre::AxisAlignedBox const &)*arg2,(Ogre::Sphere const &)*arg3,(Ogre::Camera const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::VisibleObjectsBoundsInfo.merge_non_rendered_but_in_frustum

  call-seq:
    merge_non_rendered_but_in_frustum(AxisAlignedBox boxBounds, Sphere sphereBounds, Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_merge_non_rendered_but_in_frustum(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);
  {
    try {
      (arg1)->mergeNonRenderedButInFrustum((Ogre::AxisAlignedBox const &)*arg2,(Ogre::Sphere const &)*arg3,(Ogre::Camera const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VisibleObjectsBoundsInfo(Ogre::VisibleObjectsBoundsInfo *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::SceneManager

  Proxy of C++ Ogre::SceneManager class


*/
swig_class SwigClassSceneManager;


/*
  Document-method: Ogre::SceneManager.WORLD_GEOMETRY_TYPE_MASK

  call-seq:
    WORLD_GEOMETRY_TYPE_MASK -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneManager.WORLD_GEOMETRY_TYPE_MASK=

  call-seq:
    WORLD_GEOMETRY_TYPE_MASK=(x) -> uint32

Set new value for attribute.

*/

/*
  Document-method: Ogre::SceneManager.SceneManager_WORLD_GEOMETRY_TYPE_MASK

  call-seq:
    SceneManager_WORLD_GEOMETRY_TYPE_MASK -> uint32

Get value of attribute.

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



/*
  Document-method: Ogre::SceneManager.SceneManager_WORLD_GEOMETRY_TYPE_MASK=

  call-seq:
    SceneManager_WORLD_GEOMETRY_TYPE_MASK=(x) -> uint32

Set new value for attribute.

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



/*
  Document-method: Ogre::SceneManager.ENTITY_TYPE_MASK

  call-seq:
    ENTITY_TYPE_MASK -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneManager.ENTITY_TYPE_MASK=

  call-seq:
    ENTITY_TYPE_MASK=(x) -> uint32

Set new value for attribute.

*/

/*
  Document-method: Ogre::SceneManager.SceneManager_ENTITY_TYPE_MASK

  call-seq:
    SceneManager_ENTITY_TYPE_MASK -> uint32

Get value of attribute.

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



/*
  Document-method: Ogre::SceneManager.SceneManager_ENTITY_TYPE_MASK=

  call-seq:
    SceneManager_ENTITY_TYPE_MASK=(x) -> uint32

Set new value for attribute.

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



/*
  Document-method: Ogre::SceneManager.FX_TYPE_MASK

  call-seq:
    FX_TYPE_MASK -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneManager.FX_TYPE_MASK=

  call-seq:
    FX_TYPE_MASK=(x) -> uint32

Set new value for attribute.

*/

/*
  Document-method: Ogre::SceneManager.SceneManager_FX_TYPE_MASK

  call-seq:
    SceneManager_FX_TYPE_MASK -> uint32

Get value of attribute.

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



/*
  Document-method: Ogre::SceneManager.SceneManager_FX_TYPE_MASK=

  call-seq:
    SceneManager_FX_TYPE_MASK=(x) -> uint32

Set new value for attribute.

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



/*
  Document-method: Ogre::SceneManager.STATICGEOMETRY_TYPE_MASK

  call-seq:
    STATICGEOMETRY_TYPE_MASK -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneManager.STATICGEOMETRY_TYPE_MASK=

  call-seq:
    STATICGEOMETRY_TYPE_MASK=(x) -> uint32

Set new value for attribute.

*/

/*
  Document-method: Ogre::SceneManager.SceneManager_STATICGEOMETRY_TYPE_MASK

  call-seq:
    SceneManager_STATICGEOMETRY_TYPE_MASK -> uint32

Get value of attribute.

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



/*
  Document-method: Ogre::SceneManager.SceneManager_STATICGEOMETRY_TYPE_MASK=

  call-seq:
    SceneManager_STATICGEOMETRY_TYPE_MASK=(x) -> uint32

Set new value for attribute.

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



/*
  Document-method: Ogre::SceneManager.LIGHT_TYPE_MASK

  call-seq:
    LIGHT_TYPE_MASK -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneManager.LIGHT_TYPE_MASK=

  call-seq:
    LIGHT_TYPE_MASK=(x) -> uint32

Set new value for attribute.

*/

/*
  Document-method: Ogre::SceneManager.SceneManager_LIGHT_TYPE_MASK

  call-seq:
    SceneManager_LIGHT_TYPE_MASK -> uint32

Get value of attribute.

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



/*
  Document-method: Ogre::SceneManager.SceneManager_LIGHT_TYPE_MASK=

  call-seq:
    SceneManager_LIGHT_TYPE_MASK=(x) -> uint32

Set new value for attribute.

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



/*
  Document-method: Ogre::SceneManager.FRUSTUM_TYPE_MASK

  call-seq:
    FRUSTUM_TYPE_MASK -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneManager.FRUSTUM_TYPE_MASK=

  call-seq:
    FRUSTUM_TYPE_MASK=(x) -> uint32

Set new value for attribute.

*/

/*
  Document-method: Ogre::SceneManager.SceneManager_FRUSTUM_TYPE_MASK

  call-seq:
    SceneManager_FRUSTUM_TYPE_MASK -> uint32

Get value of attribute.

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



/*
  Document-method: Ogre::SceneManager.SceneManager_FRUSTUM_TYPE_MASK=

  call-seq:
    SceneManager_FRUSTUM_TYPE_MASK=(x) -> uint32

Set new value for attribute.

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



/*
  Document-method: Ogre::SceneManager.USER_TYPE_MASK_LIMIT

  call-seq:
    USER_TYPE_MASK_LIMIT -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneManager.USER_TYPE_MASK_LIMIT=

  call-seq:
    USER_TYPE_MASK_LIMIT=(x) -> uint32

Set new value for attribute.

*/

/*
  Document-method: Ogre::SceneManager.SceneManager_USER_TYPE_MASK_LIMIT

  call-seq:
    SceneManager_USER_TYPE_MASK_LIMIT -> uint32

Get value of attribute.

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



/*
  Document-method: Ogre::SceneManager.SceneManager_USER_TYPE_MASK_LIMIT=

  call-seq:
    SceneManager_USER_TYPE_MASK_LIMIT=(x) -> uint32

Set new value for attribute.

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



/*
  Document-method: Ogre::IlluminationRenderStage.IRS_NONE

  call-seq:
    IRS_NONE -> int

A class method.

*/

/*
  Document-method: Ogre::IlluminationRenderStage.IRS_RENDER_TO_TEXTURE

  call-seq:
    IRS_RENDER_TO_TEXTURE -> int

A class method.

*/

/*
  Document-method: Ogre::IlluminationRenderStage.IRS_RENDER_RECEIVER_PASS

  call-seq:
    IRS_RENDER_RECEIVER_PASS -> int

A class method.

*/

/*
  Document-method: Ogre::SpecialCaseRenderQueueMode.SCRQM_INCLUDE

  call-seq:
    SCRQM_INCLUDE -> int

A class method.

*/

/*
  Document-method: Ogre::SpecialCaseRenderQueueMode.SCRQM_EXCLUDE

  call-seq:
    SCRQM_EXCLUDE -> int

A class method.

*/

/*
  Document-method: Ogre::SceneManager.prepare_shadow_textures

  call-seq:
    prepare_shadow_textures(Camera cam, Viewport vp, LightList lightList=0)
    prepare_shadow_textures(Camera cam, Viewport vp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_prepare_shadow_textures__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);
  {
    try {
      (arg1)->prepareShadowTextures(arg2,arg3,(Ogre::LightList const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_prepare_shadow_textures__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);
  {
    try {
      (arg1)->prepareShadowTextures(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_prepare_shadow_textures(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_prepare_shadow_textures__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_prepare_shadow_textures__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneManager.prepare_shadow_textures", 
    "    void SceneManager.prepare_shadow_textures(Ogre::Camera *cam, Ogre::Viewport *vp, Ogre::LightList const *lightList)\n"
    "    void SceneManager.prepare_shadow_textures(Ogre::Camera *cam, Ogre::Viewport *vp)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._pause_rendering

  call-seq:
    _pause_rendering -> RenderContext

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__pause_rendering(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);
  {
    try {
      result = (Ogre::SceneManager::RenderContext *)(arg1)->_pauseRendering();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager__RenderContext, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._resume_rendering

  call-seq:
    _resume_rendering(RenderContext context)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__resume_rendering(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);
  {
    try {
      (arg1)->_resumeRendering(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SceneManager(Ogre::SceneManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SceneManager.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::SceneManager const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_type_name

  call-seq:
    get_type_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_type_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::SceneManager const *)arg1)->getTypeName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_camera

  call-seq:
    create_camera(String name) -> Camera

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_camera(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;
  }
  {
    try {
      result = (Ogre::Camera *)(arg1)->createCamera((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_camera

  call-seq:
    get_camera(String name) -> Camera

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_camera(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;
  }
  {
    try {
      result = (Ogre::Camera *)((Ogre::SceneManager const *)arg1)->getCamera((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_camera

  call-seq:
    has_camera(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_camera(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasCamera((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_camera

  call-seq:
    destroy_camera(Camera cam)
    destroy_camera(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_camera__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);
  {
    try {
      (arg1)->destroyCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroy_camera__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;
  }
  {
    try {
      (arg1)->destroyCamera((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_camera(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_destroy_camera__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_destroy_camera__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroy_camera", 
    "    void SceneManager.destroy_camera(Ogre::Camera *cam)\n"
    "    void SceneManager.destroy_camera(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_cameras

  call-seq:
    destroy_all_cameras

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_cameras(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);
  {
    try {
      (arg1)->destroyAllCameras();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_light

  call-seq:
    create_light(String name) -> Light
    create_light -> Light

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_light__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;
  }
  {
    try {
      result = (Ogre::Light *)(arg1)->createLight((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_light__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);
  {
    try {
      result = (Ogre::Light *)(arg1)->createLight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Light, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_create_light(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_create_light__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_create_light__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.create_light", 
    "    Ogre::Light * SceneManager.create_light(Ogre::String const &name)\n"
    "    Ogre::Light * SceneManager.create_light()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_light

  call-seq:
    get_light(String name) -> Light

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_light(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;
  }
  {
    try {
      result = (Ogre::Light *)((Ogre::SceneManager const *)arg1)->getLight((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_light

  call-seq:
    has_light(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_light(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasLight((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_light_clipping_planes

  call-seq:
    get_light_clipping_planes(Light l) -> PlaneList

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_light_clipping_planes(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);
  {
    try {
      result = (Ogre::PlaneList *) &(arg1)->getLightClippingPlanes(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_light_scissor_rect

  call-seq:
    get_light_scissor_rect(Light l, Camera cam) -> RealRect

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_light_scissor_rect(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);
  {
    try {
      result = (Ogre::RealRect *) &(arg1)->getLightScissorRect(arg2,(Ogre::Camera const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TRectT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_light

  call-seq:
    destroy_light(String name)
    destroy_light(Light light)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_light__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;
  }
  {
    try {
      (arg1)->destroyLight((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroy_light__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);
  {
    try {
      (arg1)->destroyLight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_light(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_destroy_light__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_destroy_light__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroy_light", 
    "    void SceneManager.destroy_light(Ogre::String const &name)\n"
    "    void SceneManager.destroy_light(Ogre::Light *light)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_lights

  call-seq:
    destroy_all_lights

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_lights(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);
  {
    try {
      (arg1)->destroyAllLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._notify_lights_dirty

  call-seq:
    _notify_lights_dirty

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__notify_lights_dirty(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);
  {
    try {
      (arg1)->_notifyLightsDirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._get_lights_dirty_counter

  call-seq:
    _get_lights_dirty_counter -> ulong

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__get_lights_dirty_counter(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);
  {
    try {
      result = (Ogre::ulong)((Ogre::SceneManager const *)arg1)->_getLightsDirtyCounter();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._get_lights_affecting_frustum

  call-seq:
    _get_lights_affecting_frustum -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__get_lights_affecting_frustum(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::SceneManager const *)arg1)->_getLightsAffectingFrustum();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._populate_light_list

  call-seq:
    _populate_light_list(Vector3 position, Real radius, LightList destList, 
    uint32 lightMask=0xFFFFFFFF)
    _populate_light_list(Vector3 position, Real radius, LightList destList)
    _populate_light_list(SceneNode sn, Real radius, LightList destList, uint32 lightMask=0xFFFFFFFF)
    _populate_light_list(SceneNode sn, Real radius, LightList destList)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__populate_light_list__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);
  {
    try {
      (arg1)->_populateLightList((Ogre::Vector3 const &)*arg2,arg3,*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__populate_light_list__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);
  {
    try {
      (arg1)->_populateLightList((Ogre::Vector3 const &)*arg2,arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__populate_light_list__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);
  {
    try {
      (arg1)->_populateLightList((Ogre::SceneNode const *)arg2,arg3,*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__populate_light_list__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);
  {
    try {
      (arg1)->_populateLightList((Ogre::SceneNode const *)arg2,arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager__populate_light_list(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__populate_light_list__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__populate_light_list__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__populate_light_list__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__populate_light_list__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "SceneManager._populate_light_list", 
    "    void SceneManager._populate_light_list(Ogre::Vector3 const &position, Ogre::Real radius, Ogre::LightList &destList, Ogre::uint32 lightMask)\n"
    "    void SceneManager._populate_light_list(Ogre::Vector3 const &position, Ogre::Real radius, Ogre::LightList &destList)\n"
    "    void SceneManager._populate_light_list(Ogre::SceneNode const *sn, Ogre::Real radius, Ogre::LightList &destList, Ogre::uint32 lightMask)\n"
    "    void SceneManager._populate_light_list(Ogre::SceneNode const *sn, Ogre::Real radius, Ogre::LightList &destList)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_scene_node

  call-seq:
    create_scene_node -> SceneNode
    create_scene_node(String name) -> SceneNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_scene_node__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);
  {
    try {
      result = (Ogre::SceneNode *)(arg1)->createSceneNode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_create_scene_node__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;
  }
  {
    try {
      result = (Ogre::SceneNode *)(arg1)->createSceneNode((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_scene_node(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_create_scene_node__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_create_scene_node__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.create_scene_node", 
    "    Ogre::SceneNode * SceneManager.create_scene_node()\n"
    "    Ogre::SceneNode * SceneManager.create_scene_node(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_scene_node

  call-seq:
    destroy_scene_node(String name)
    destroy_scene_node(SceneNode sn)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_scene_node__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;
  }
  {
    try {
      (arg1)->destroySceneNode((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroy_scene_node__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);
  {
    try {
      (arg1)->destroySceneNode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_scene_node(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_destroy_scene_node__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_destroy_scene_node__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroy_scene_node", 
    "    void SceneManager.destroy_scene_node(Ogre::String const &name)\n"
    "    void SceneManager.destroy_scene_node(Ogre::SceneNode *sn)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_root_scene_node

  call-seq:
    get_root_scene_node -> SceneNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_root_scene_node(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);
  {
    try {
      result = (Ogre::SceneNode *)(arg1)->getRootSceneNode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_scene_node

  call-seq:
    get_scene_node(String name) -> SceneNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_scene_node(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;
  }
  {
    try {
      result = (Ogre::SceneNode *)((Ogre::SceneManager const *)arg1)->getSceneNode((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_scene_node

  call-seq:
    has_scene_node(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_scene_node(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasSceneNode((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_entity

  call-seq:
    create_entity(String entityName, String meshName, String groupName=AUTODETECT_RESOURCE_GROUP_NAME) -> Entity
    create_entity(String entityName, String meshName) -> Entity
    create_entity(String entityName, MeshPtr pMesh) -> Entity
    create_entity(String meshName) -> Entity
    create_entity(MeshPtr pMesh) -> Entity
    create_entity(String entityName, PrefabType ptype) -> Entity
    create_entity(PrefabType ptype) -> Entity

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_entity__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;
  }
  {
    try {
      result = (Ogre::Entity *)(arg1)->createEntity((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_entity__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;
  }
  {
    try {
      result = (Ogre::Entity *)(arg1)->createEntity((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_create_entity__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);
  {
    try {
      result = (Ogre::Entity *)(arg1)->createEntity((Ogre::String const &)*arg2,(Ogre::MeshPtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_entity__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;
  }
  {
    try {
      result = (Ogre::Entity *)(arg1)->createEntity((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_entity__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);
  {
    try {
      result = (Ogre::Entity *)(arg1)->createEntity((Ogre::MeshPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PrefabType.PT_PLANE

  call-seq:
    PT_PLANE -> int

A class method.

*/

/*
  Document-method: Ogre::PrefabType.PT_CUBE

  call-seq:
    PT_CUBE -> int

A class method.

*/

/*
  Document-method: Ogre::PrefabType.PT_SPHERE

  call-seq:
    PT_SPHERE -> int

A class method.

*/

/*
  Document-method: Ogre::SceneManager.create_entity

  call-seq:
    create_entity(String entityName, String meshName, String groupName=AUTODETECT_RESOURCE_GROUP_NAME) -> Entity
    create_entity(String entityName, String meshName) -> Entity
    create_entity(String entityName, MeshPtr pMesh) -> Entity
    create_entity(String meshName) -> Entity
    create_entity(MeshPtr pMesh) -> Entity
    create_entity(String entityName, PrefabType ptype) -> Entity
    create_entity(PrefabType ptype) -> Entity

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_entity__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);
  {
    try {
      result = (Ogre::Entity *)(arg1)->createEntity((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_entity__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);
  {
    try {
      result = (Ogre::Entity *)(arg1)->createEntity(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_create_entity(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_create_entity__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_create_entity__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_create_entity__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_create_entity__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_create_entity__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_create_entity__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_create_entity__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneManager.create_entity", 
    "    Ogre::Entity * SceneManager.create_entity(Ogre::String const &entityName, Ogre::String const &meshName, Ogre::String const &groupName)\n"
    "    Ogre::Entity * SceneManager.create_entity(Ogre::String const &entityName, Ogre::String const &meshName)\n"
    "    Ogre::Entity * SceneManager.create_entity(Ogre::String const &entityName, Ogre::MeshPtr const &pMesh)\n"
    "    Ogre::Entity * SceneManager.create_entity(Ogre::String const &meshName)\n"
    "    Ogre::Entity * SceneManager.create_entity(Ogre::MeshPtr const &pMesh)\n"
    "    Ogre::Entity * SceneManager.create_entity(Ogre::String const &entityName, Ogre::SceneManager::PrefabType ptype)\n"
    "    Ogre::Entity * SceneManager.create_entity(Ogre::SceneManager::PrefabType ptype)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_entity

  call-seq:
    get_entity(String name) -> Entity

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_entity(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;
  }
  {
    try {
      result = (Ogre::Entity *)((Ogre::SceneManager const *)arg1)->getEntity((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_entity

  call-seq:
    has_entity(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_entity(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasEntity((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_entity

  call-seq:
    destroy_entity(Entity ent)
    destroy_entity(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_entity__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);
  {
    try {
      (arg1)->destroyEntity(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroy_entity__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;
  }
  {
    try {
      (arg1)->destroyEntity((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_entity(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_destroy_entity__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_destroy_entity__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroy_entity", 
    "    void SceneManager.destroy_entity(Ogre::Entity *ent)\n"
    "    void SceneManager.destroy_entity(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_entities

  call-seq:
    destroy_all_entities

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_entities(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);
  {
    try {
      (arg1)->destroyAllEntities();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_manual_object

  call-seq:
    create_manual_object(String name) -> ManualObject
    create_manual_object -> ManualObject

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_manual_object__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;
  }
  {
    try {
      result = (Ogre::ManualObject *)(arg1)->createManualObject((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_manual_object__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);
  {
    try {
      result = (Ogre::ManualObject *)(arg1)->createManualObject();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ManualObject, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_create_manual_object(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_create_manual_object__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_create_manual_object__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.create_manual_object", 
    "    Ogre::ManualObject * SceneManager.create_manual_object(Ogre::String const &name)\n"
    "    Ogre::ManualObject * SceneManager.create_manual_object()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_manual_object

  call-seq:
    get_manual_object(String name) -> ManualObject

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_manual_object(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;
  }
  {
    try {
      result = (Ogre::ManualObject *)((Ogre::SceneManager const *)arg1)->getManualObject((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ManualObject, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_manual_object

  call-seq:
    has_manual_object(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_manual_object(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasManualObject((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_manual_object

  call-seq:
    destroy_manual_object(ManualObject obj)
    destroy_manual_object(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_manual_object__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);
  {
    try {
      (arg1)->destroyManualObject(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroy_manual_object__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;
  }
  {
    try {
      (arg1)->destroyManualObject((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_manual_object(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_destroy_manual_object__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_destroy_manual_object__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroy_manual_object", 
    "    void SceneManager.destroy_manual_object(Ogre::ManualObject *obj)\n"
    "    void SceneManager.destroy_manual_object(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_manual_objects

  call-seq:
    destroy_all_manual_objects

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_manual_objects(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);
  {
    try {
      (arg1)->destroyAllManualObjects();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_billboard_chain

  call-seq:
    create_billboard_chain(String name) -> BillboardChain
    create_billboard_chain -> BillboardChain

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_billboard_chain__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;
  }
  {
    try {
      result = (Ogre::BillboardChain *)(arg1)->createBillboardChain((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_billboard_chain__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);
  {
    try {
      result = (Ogre::BillboardChain *)(arg1)->createBillboardChain();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardChain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_create_billboard_chain(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_create_billboard_chain__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_create_billboard_chain__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.create_billboard_chain", 
    "    Ogre::BillboardChain * SceneManager.create_billboard_chain(Ogre::String const &name)\n"
    "    Ogre::BillboardChain * SceneManager.create_billboard_chain()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_billboard_chain

  call-seq:
    get_billboard_chain(String name) -> BillboardChain

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_billboard_chain(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;
  }
  {
    try {
      result = (Ogre::BillboardChain *)((Ogre::SceneManager const *)arg1)->getBillboardChain((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardChain, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_billboard_chain

  call-seq:
    has_billboard_chain(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_billboard_chain(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasBillboardChain((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_billboard_chain

  call-seq:
    destroy_billboard_chain(BillboardChain obj)
    destroy_billboard_chain(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_billboard_chain__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);
  {
    try {
      (arg1)->destroyBillboardChain(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroy_billboard_chain__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;
  }
  {
    try {
      (arg1)->destroyBillboardChain((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_billboard_chain(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_destroy_billboard_chain__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_destroy_billboard_chain__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroy_billboard_chain", 
    "    void SceneManager.destroy_billboard_chain(Ogre::BillboardChain *obj)\n"
    "    void SceneManager.destroy_billboard_chain(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_billboard_chains

  call-seq:
    destroy_all_billboard_chains

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_billboard_chains(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);
  {
    try {
      (arg1)->destroyAllBillboardChains();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_ribbon_trail

  call-seq:
    create_ribbon_trail(String name) -> RibbonTrail
    create_ribbon_trail -> RibbonTrail

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_ribbon_trail__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;
  }
  {
    try {
      result = (Ogre::RibbonTrail *)(arg1)->createRibbonTrail((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_ribbon_trail__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);
  {
    try {
      result = (Ogre::RibbonTrail *)(arg1)->createRibbonTrail();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RibbonTrail, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_create_ribbon_trail(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_create_ribbon_trail__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_create_ribbon_trail__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.create_ribbon_trail", 
    "    Ogre::RibbonTrail * SceneManager.create_ribbon_trail(Ogre::String const &name)\n"
    "    Ogre::RibbonTrail * SceneManager.create_ribbon_trail()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_ribbon_trail

  call-seq:
    get_ribbon_trail(String name) -> RibbonTrail

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_ribbon_trail(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;
  }
  {
    try {
      result = (Ogre::RibbonTrail *)((Ogre::SceneManager const *)arg1)->getRibbonTrail((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RibbonTrail, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_ribbon_trail

  call-seq:
    has_ribbon_trail(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_ribbon_trail(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasRibbonTrail((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_ribbon_trail

  call-seq:
    destroy_ribbon_trail(RibbonTrail obj)
    destroy_ribbon_trail(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_ribbon_trail__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);
  {
    try {
      (arg1)->destroyRibbonTrail(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroy_ribbon_trail__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;
  }
  {
    try {
      (arg1)->destroyRibbonTrail((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_ribbon_trail(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_destroy_ribbon_trail__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_destroy_ribbon_trail__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroy_ribbon_trail", 
    "    void SceneManager.destroy_ribbon_trail(Ogre::RibbonTrail *obj)\n"
    "    void SceneManager.destroy_ribbon_trail(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_ribbon_trails

  call-seq:
    destroy_all_ribbon_trails

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_ribbon_trails(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);
  {
    try {
      (arg1)->destroyAllRibbonTrails();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_particle_system

  call-seq:
    create_particle_system(String name, String templateName) -> ParticleSystem
    create_particle_system(String name, size_t quota=500, String resourceGroup=DEFAULT_RESOURCE_GROUP_NAME) -> ParticleSystem
    create_particle_system(String name, size_t quota=500) -> ParticleSystem
    create_particle_system(String name) -> ParticleSystem
    create_particle_system(size_t quota=500, String resourceGroup=DEFAULT_RESOURCE_GROUP_NAME) -> ParticleSystem
    create_particle_system(size_t quota=500) -> ParticleSystem
    create_particle_system -> ParticleSystem

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_particle_system__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;
  }
  {
    try {
      result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_create_particle_system__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;
  }
  {
    try {
      result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_particle_system__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);
  {
    try {
      result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_particle_system__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;
  }
  {
    try {
      result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_particle_system__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;
  }
  {
    try {
      result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_create_particle_system__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);
  {
    try {
      result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_create_particle_system__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);
  {
    try {
      result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_create_particle_system(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_create_particle_system__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_create_particle_system__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_create_particle_system__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_create_particle_system__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_create_particle_system__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_create_particle_system__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_create_particle_system__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneManager.create_particle_system", 
    "    Ogre::ParticleSystem * SceneManager.create_particle_system(Ogre::String const &name, Ogre::String const &templateName)\n"
    "    Ogre::ParticleSystem * SceneManager.create_particle_system(Ogre::String const &name, size_t quota, Ogre::String const &resourceGroup)\n"
    "    Ogre::ParticleSystem * SceneManager.create_particle_system(Ogre::String const &name, size_t quota)\n"
    "    Ogre::ParticleSystem * SceneManager.create_particle_system(Ogre::String const &name)\n"
    "    Ogre::ParticleSystem * SceneManager.create_particle_system(size_t quota, Ogre::String const &resourceGroup)\n"
    "    Ogre::ParticleSystem * SceneManager.create_particle_system(size_t quota)\n"
    "    Ogre::ParticleSystem * SceneManager.create_particle_system()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_particle_system

  call-seq:
    get_particle_system(String name) -> ParticleSystem

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_particle_system(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;
  }
  {
    try {
      result = (Ogre::ParticleSystem *)((Ogre::SceneManager const *)arg1)->getParticleSystem((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_particle_system

  call-seq:
    has_particle_system(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_particle_system(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasParticleSystem((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_particle_system

  call-seq:
    destroy_particle_system(ParticleSystem obj)
    destroy_particle_system(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_particle_system__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);
  {
    try {
      (arg1)->destroyParticleSystem(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroy_particle_system__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;
  }
  {
    try {
      (arg1)->destroyParticleSystem((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_particle_system(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_destroy_particle_system__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_destroy_particle_system__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroy_particle_system", 
    "    void SceneManager.destroy_particle_system(Ogre::ParticleSystem *obj)\n"
    "    void SceneManager.destroy_particle_system(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_particle_systems

  call-seq:
    destroy_all_particle_systems

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_particle_systems(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);
  {
    try {
      (arg1)->destroyAllParticleSystems();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.clear_scene

  call-seq:
    clear_scene

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_clear_scene(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);
  {
    try {
      (arg1)->clearScene();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_ambient_light

  call-seq:
    set_ambient_light(ColourValue colour)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_ambient_light(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);
  {
    try {
      (arg1)->setAmbientLight((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_ambient_light

  call-seq:
    get_ambient_light -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_ambient_light(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::SceneManager const *)arg1)->getAmbientLight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.prepare_world_geometry

  call-seq:
    prepare_world_geometry(String filename)
    prepare_world_geometry(DataStreamPtr stream, String typeName=BLANK)
    prepare_world_geometry(DataStreamPtr stream)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_prepare_world_geometry__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;
  }
  {
    try {
      (arg1)->prepareWorldGeometry((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_prepare_world_geometry__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;
  }
  {
    try {
      (arg1)->prepareWorldGeometry(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_prepare_world_geometry__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);
  {
    try {
      (arg1)->prepareWorldGeometry(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_prepare_world_geometry(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_prepare_world_geometry__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_prepare_world_geometry__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_prepare_world_geometry__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.prepare_world_geometry", 
    "    void SceneManager.prepare_world_geometry(Ogre::String const &filename)\n"
    "    void SceneManager.prepare_world_geometry(Ogre::DataStreamPtr &stream, Ogre::String const &typeName)\n"
    "    void SceneManager.prepare_world_geometry(Ogre::DataStreamPtr &stream)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_world_geometry

  call-seq:
    set_world_geometry(String filename)
    set_world_geometry(DataStreamPtr stream, String typeName=BLANK)
    set_world_geometry(DataStreamPtr stream)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_world_geometry__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;
  }
  {
    try {
      (arg1)->setWorldGeometry((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_world_geometry__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;
  }
  {
    try {
      (arg1)->setWorldGeometry(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_world_geometry__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);
  {
    try {
      (arg1)->setWorldGeometry(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_set_world_geometry(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_set_world_geometry__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_set_world_geometry__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_set_world_geometry__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.set_world_geometry", 
    "    void SceneManager.set_world_geometry(Ogre::String const &filename)\n"
    "    void SceneManager.set_world_geometry(Ogre::DataStreamPtr &stream, Ogre::String const &typeName)\n"
    "    void SceneManager.set_world_geometry(Ogre::DataStreamPtr &stream)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.estimate_world_geometry

  call-seq:
    estimate_world_geometry(String filename) -> size_t
    estimate_world_geometry(DataStreamPtr stream, String typeName=BLANK) -> size_t
    estimate_world_geometry(DataStreamPtr stream) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_estimate_world_geometry__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;
  }
  {
    try {
      result = (arg1)->estimateWorldGeometry((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_estimate_world_geometry__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;
  }
  {
    try {
      result = (arg1)->estimateWorldGeometry(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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_estimate_world_geometry__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);
  {
    try {
      result = (arg1)->estimateWorldGeometry(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_estimate_world_geometry(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_estimate_world_geometry__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_estimate_world_geometry__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_estimate_world_geometry__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.estimate_world_geometry", 
    "    size_t SceneManager.estimate_world_geometry(Ogre::String const &filename)\n"
    "    size_t SceneManager.estimate_world_geometry(Ogre::DataStreamPtr &stream, Ogre::String const &typeName)\n"
    "    size_t SceneManager.estimate_world_geometry(Ogre::DataStreamPtr &stream)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_suggested_viewpoint

  call-seq:
    get_suggested_viewpoint(bool random=false) -> ViewPoint
    get_suggested_viewpoint -> ViewPoint

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_suggested_viewpoint__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);
  {
    try {
      result = (arg1)->getSuggestedViewpoint(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ViewPoint(static_cast< const Ogre::ViewPoint& >(result))), SWIGTYPE_p_Ogre__ViewPoint, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_get_suggested_viewpoint__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);
  {
    try {
      result = (arg1)->getSuggestedViewpoint();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ViewPoint(static_cast< const Ogre::ViewPoint& >(result))), SWIGTYPE_p_Ogre__ViewPoint, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_get_suggested_viewpoint(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_get_suggested_viewpoint__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_get_suggested_viewpoint__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.get_suggested_viewpoint", 
    "    Ogre::ViewPoint SceneManager.get_suggested_viewpoint(bool random)\n"
    "    Ogre::ViewPoint SceneManager.get_suggested_viewpoint()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_option

  call-seq:
    set_option(String strKey, void pValue) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_option(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] )); 
  }
  {
    try {
      result = (bool)(arg1)->setOption((Ogre::String const &)*arg2,(void const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_option

  call-seq:
    get_option(String strKey, void pDestValue) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_option(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] )); 
  }
  {
    try {
      result = (bool)(arg1)->getOption((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_option

  call-seq:
    has_option(String strKey) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_option(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasOption((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_option_values

  call-seq:
    get_option_values(String strKey, StringVector refValueList) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_option_values(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);
  {
    try {
      result = (bool)(arg1)->getOptionValues((Ogre::String const &)*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_option_keys

  call-seq:
    get_option_keys(StringVector refKeys) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_option_keys(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);
  {
    try {
      result = (bool)(arg1)->getOptionKeys(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._update_scene_graph

  call-seq:
    _update_scene_graph(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__update_scene_graph(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);
  {
    try {
      (arg1)->_updateSceneGraph(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._find_visible_objects

  call-seq:
    _find_visible_objects(Camera cam, VisibleObjectsBoundsInfo visibleBounds, 
    bool onlyShadowCasters)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__find_visible_objects(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);
  {
    try {
      (arg1)->_findVisibleObjects(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._apply_scene_animations

  call-seq:
    _apply_scene_animations

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__apply_scene_animations(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);
  {
    try {
      (arg1)->_applySceneAnimations();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._render_visible_objects

  call-seq:
    _render_visible_objects

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__render_visible_objects(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);
  {
    try {
      (arg1)->_renderVisibleObjects();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._render_scene

  call-seq:
    _render_scene(Camera camera, Viewport vp, bool includeOverlays)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__render_scene(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);
  {
    try {
      (arg1)->_renderScene(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._queue_skies_for_rendering

  call-seq:
    _queue_skies_for_rendering(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__queue_skies_for_rendering(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);
  {
    try {
      (arg1)->_queueSkiesForRendering(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._set_destination_render_system

  call-seq:
    _set_destination_render_system(RenderSystem sys)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__set_destination_render_system(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);
  {
    try {
      (arg1)->_setDestinationRenderSystem(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_sky_plane

  call-seq:
    set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000, 
    Real tiling=10, bool drawFirst=true, 
    Real bow=0, int xsegments=1, int ysegments=1, 
    String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000, 
    Real tiling=10, bool drawFirst=true, 
    Real bow=0, int xsegments=1, int ysegments=1)
    set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000, 
    Real tiling=10, bool drawFirst=true, 
    Real bow=0, int xsegments=1)
    set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000, 
    Real tiling=10, bool drawFirst=true, 
    Real bow=0)
    set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000, 
    Real tiling=10, bool drawFirst=true)
    set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000, 
    Real tiling=10)
    set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000)
    set_sky_plane(bool enable, Plane plane, String materialName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_sky_plane__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;
  }
  {
    try {
      (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,(Ogre::String const &)*arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_set_sky_plane__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);
  {
    try {
      (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_plane__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);
  {
    try {
      (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_plane__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);
  {
    try {
      (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_plane__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);
  {
    try {
      (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_plane__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);
  {
    try {
      (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_plane__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);
  {
    try {
      (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_plane__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;
  }
  {
    try {
      (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_set_sky_plane(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_set_sky_plane__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_set_sky_plane__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_set_sky_plane__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_set_sky_plane__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_set_sky_plane__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_set_sky_plane__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_set_sky_plane__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_set_sky_plane__SWIG_0(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 12, "SceneManager.set_sky_plane", 
    "    void SceneManager.set_sky_plane(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.set_sky_plane(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.set_sky_plane(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.set_sky_plane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, bool drawFirst, Ogre::Real bow)\n"
    "    void SceneManager.set_sky_plane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, bool drawFirst)\n"
    "    void SceneManager.set_sky_plane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling)\n"
    "    void SceneManager.set_sky_plane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale)\n"
    "    void SceneManager.set_sky_plane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._set_sky_plane

  call-seq:
    _set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000, 
    Real tiling=10, uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY, 
    Real bow=0, int xsegments=1, 
    int ysegments=1, String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    _set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000, 
    Real tiling=10, uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY, 
    Real bow=0, int xsegments=1, 
    int ysegments=1)
    _set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000, 
    Real tiling=10, uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY, 
    Real bow=0, int xsegments=1)
    _set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000, 
    Real tiling=10, uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY, 
    Real bow=0)
    _set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000, 
    Real tiling=10, uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY)
    _set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000, 
    Real tiling=10)
    _set_sky_plane(bool enable, Plane plane, String materialName, Real scale=1000)
    _set_sky_plane(bool enable, Plane plane, String materialName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__set_sky_plane__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;
  }
  {
    try {
      (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,(Ogre::String const &)*arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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__set_sky_plane__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);
  {
    try {
      (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_plane__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);
  {
    try {
      (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_plane__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);
  {
    try {
      (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_plane__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);
  {
    try {
      (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_plane__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);
  {
    try {
      (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_plane__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);
  {
    try {
      (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_plane__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;
  }
  {
    try {
      (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager__set_sky_plane(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__set_sky_plane__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__set_sky_plane__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__set_sky_plane__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__set_sky_plane__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__set_sky_plane__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__set_sky_plane__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__set_sky_plane__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__set_sky_plane__SWIG_0(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 12, "SceneManager._set_sky_plane", 
    "    void SceneManager._set_sky_plane(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._set_sky_plane(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._set_sky_plane(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._set_sky_plane(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._set_sky_plane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, Ogre::uint8 renderQueue)\n"
    "    void SceneManager._set_sky_plane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling)\n"
    "    void SceneManager._set_sky_plane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale)\n"
    "    void SceneManager._set_sky_plane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_sky_plane_enabled

  call-seq:
    set_sky_plane_enabled(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_sky_plane_enabled(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);
  {
    try {
      (arg1)->setSkyPlaneEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.is_sky_plane_enabled

  call-seq:
    is_sky_plane_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_is_sky_plane_enabled(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->isSkyPlaneEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_sky_plane_node

  call-seq:
    get_sky_plane_node -> SceneNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_sky_plane_node(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);
  {
    try {
      result = (Ogre::SceneNode *)((Ogre::SceneManager const *)arg1)->getSkyPlaneNode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_sky_plane_gen_parameters

  call-seq:
    get_sky_plane_gen_parameters -> SkyPlaneGenParameters

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_sky_plane_gen_parameters(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);
  {
    try {
      result = (Ogre::SceneManager::SkyPlaneGenParameters *) &((Ogre::SceneManager const *)arg1)->getSkyPlaneGenParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager__SkyPlaneGenParameters, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_sky_box

  call-seq:
    set_sky_box(bool enable, String materialName, Real distance=5000, 
    bool drawFirst=true, Quaternion orientation=IDENTITY, 
    String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    set_sky_box(bool enable, String materialName, Real distance=5000, 
    bool drawFirst=true, Quaternion orientation=IDENTITY)
    set_sky_box(bool enable, String materialName, Real distance=5000, 
    bool drawFirst=true)
    set_sky_box(bool enable, String materialName, Real distance=5000)
    set_sky_box(bool enable, String materialName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_sky_box__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;
  }
  {
    try {
      (arg1)->setSkyBox(arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::Quaternion const &)*arg6,(Ogre::String const &)*arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_set_sky_box__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);
  {
    try {
      (arg1)->setSkyBox(arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::Quaternion const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_box__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);
  {
    try {
      (arg1)->setSkyBox(arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_box__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);
  {
    try {
      (arg1)->setSkyBox(arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_box__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;
  }
  {
    try {
      (arg1)->setSkyBox(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_set_sky_box(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_set_sky_box__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_set_sky_box__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_set_sky_box__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_set_sky_box__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_set_sky_box__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "SceneManager.set_sky_box", 
    "    void SceneManager.set_sky_box(bool enable, Ogre::String const &materialName, Ogre::Real distance, bool drawFirst, Ogre::Quaternion const &orientation, Ogre::String const &groupName)\n"
    "    void SceneManager.set_sky_box(bool enable, Ogre::String const &materialName, Ogre::Real distance, bool drawFirst, Ogre::Quaternion const &orientation)\n"
    "    void SceneManager.set_sky_box(bool enable, Ogre::String const &materialName, Ogre::Real distance, bool drawFirst)\n"
    "    void SceneManager.set_sky_box(bool enable, Ogre::String const &materialName, Ogre::Real distance)\n"
    "    void SceneManager.set_sky_box(bool enable, Ogre::String const &materialName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._set_sky_box

  call-seq:
    _set_sky_box(bool enable, String materialName, Real distance=5000, 
    uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY, 
    Quaternion orientation=IDENTITY, String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    _set_sky_box(bool enable, String materialName, Real distance=5000, 
    uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY, 
    Quaternion orientation=IDENTITY)
    _set_sky_box(bool enable, String materialName, Real distance=5000, 
    uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY)
    _set_sky_box(bool enable, String materialName, Real distance=5000)
    _set_sky_box(bool enable, String materialName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__set_sky_box__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;
  }
  {
    try {
      (arg1)->_setSkyBox(arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::Quaternion const &)*arg6,(Ogre::String const &)*arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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__set_sky_box__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);
  {
    try {
      (arg1)->_setSkyBox(arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::Quaternion const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_box__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);
  {
    try {
      (arg1)->_setSkyBox(arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_box__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);
  {
    try {
      (arg1)->_setSkyBox(arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_box__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;
  }
  {
    try {
      (arg1)->_setSkyBox(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager__set_sky_box(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__set_sky_box__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__set_sky_box__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__set_sky_box__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__set_sky_box__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__set_sky_box__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "SceneManager._set_sky_box", 
    "    void SceneManager._set_sky_box(bool enable, Ogre::String const &materialName, Ogre::Real distance, Ogre::uint8 renderQueue, Ogre::Quaternion const &orientation, Ogre::String const &groupName)\n"
    "    void SceneManager._set_sky_box(bool enable, Ogre::String const &materialName, Ogre::Real distance, Ogre::uint8 renderQueue, Ogre::Quaternion const &orientation)\n"
    "    void SceneManager._set_sky_box(bool enable, Ogre::String const &materialName, Ogre::Real distance, Ogre::uint8 renderQueue)\n"
    "    void SceneManager._set_sky_box(bool enable, Ogre::String const &materialName, Ogre::Real distance)\n"
    "    void SceneManager._set_sky_box(bool enable, Ogre::String const &materialName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_sky_box_enabled

  call-seq:
    set_sky_box_enabled(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_sky_box_enabled(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);
  {
    try {
      (arg1)->setSkyBoxEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.is_sky_box_enabled

  call-seq:
    is_sky_box_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_is_sky_box_enabled(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->isSkyBoxEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_sky_box_node

  call-seq:
    get_sky_box_node -> SceneNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_sky_box_node(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);
  {
    try {
      result = (Ogre::SceneNode *)((Ogre::SceneManager const *)arg1)->getSkyBoxNode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_sky_box_gen_parameters

  call-seq:
    get_sky_box_gen_parameters -> SkyBoxGenParameters

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_sky_box_gen_parameters(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);
  {
    try {
      result = (Ogre::SceneManager::SkyBoxGenParameters *) &((Ogre::SceneManager const *)arg1)->getSkyBoxGenParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager__SkyBoxGenParameters, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_sky_dome

  call-seq:
    set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000, bool drawFirst=true, 
    Quaternion orientation=IDENTITY, 
    int xsegments=16, int ysegments=16, int ysegments_keep=-1, 
    String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000, bool drawFirst=true, 
    Quaternion orientation=IDENTITY, 
    int xsegments=16, int ysegments=16, int ysegments_keep=-1)
    set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000, bool drawFirst=true, 
    Quaternion orientation=IDENTITY, 
    int xsegments=16, int ysegments=16)
    set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000, bool drawFirst=true, 
    Quaternion orientation=IDENTITY, 
    int xsegments=16)
    set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000, bool drawFirst=true, 
    Quaternion orientation=IDENTITY)
    set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000, bool drawFirst=true)
    set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000)
    set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8)
    set_sky_dome(bool enable, String materialName, Real curvature=10)
    set_sky_dome(bool enable, String materialName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_sky_dome__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;
  }
  {
    try {
      (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9,arg10,arg11,(Ogre::String const &)*arg12);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_set_sky_dome__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);
  {
    try {
      (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9,arg10,arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_dome__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);
  {
    try {
      (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_dome__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);
  {
    try {
      (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_dome__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);
  {
    try {
      (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_dome__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);
  {
    try {
      (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_dome__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);
  {
    try {
      (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_dome__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);
  {
    try {
      (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_dome__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);
  {
    try {
      (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_sky_dome__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;
  }
  {
    try {
      (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_set_sky_dome(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_set_sky_dome__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_set_sky_dome__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_set_sky_dome__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_set_sky_dome__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_set_sky_dome__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_set_sky_dome__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_set_sky_dome__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_set_sky_dome__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_set_sky_dome__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_set_sky_dome__SWIG_0(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 13, "SceneManager.set_sky_dome", 
    "    void SceneManager.set_sky_dome(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.set_sky_dome(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.set_sky_dome(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.set_sky_dome(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.set_sky_dome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, bool drawFirst, Ogre::Quaternion const &orientation)\n"
    "    void SceneManager.set_sky_dome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, bool drawFirst)\n"
    "    void SceneManager.set_sky_dome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance)\n"
    "    void SceneManager.set_sky_dome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling)\n"
    "    void SceneManager.set_sky_dome(bool enable, Ogre::String const &materialName, Ogre::Real curvature)\n"
    "    void SceneManager.set_sky_dome(bool enable, Ogre::String const &materialName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._set_sky_dome

  call-seq:
    _set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000, uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY, 
    Quaternion orientation=IDENTITY, 
    int xsegments=16, int ysegments=16, 
    int ysegments_keep=-1, String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    _set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000, uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY, 
    Quaternion orientation=IDENTITY, 
    int xsegments=16, int ysegments=16, 
    int ysegments_keep=-1)
    _set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000, uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY, 
    Quaternion orientation=IDENTITY, 
    int xsegments=16, int ysegments=16)
    _set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000, uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY, 
    Quaternion orientation=IDENTITY, 
    int xsegments=16)
    _set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000, uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY, 
    Quaternion orientation=IDENTITY)
    _set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000, uint8 renderQueue=RENDER_QUEUE_SKIES_EARLY)
    _set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8, Real distance=4000)
    _set_sky_dome(bool enable, String materialName, Real curvature=10, 
    Real tiling=8)
    _set_sky_dome(bool enable, String materialName, Real curvature=10)
    _set_sky_dome(bool enable, String materialName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__set_sky_dome__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;
  }
  {
    try {
      (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9,arg10,arg11,(Ogre::String const &)*arg12);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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__set_sky_dome__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);
  {
    try {
      (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9,arg10,arg11);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_dome__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);
  {
    try {
      (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9,arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_dome__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);
  {
    try {
      (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_dome__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);
  {
    try {
      (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_dome__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);
  {
    try {
      (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_dome__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);
  {
    try {
      (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_dome__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);
  {
    try {
      (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_dome__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);
  {
    try {
      (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_sky_dome__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;
  }
  {
    try {
      (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager__set_sky_dome(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__set_sky_dome__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__set_sky_dome__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__set_sky_dome__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__set_sky_dome__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__set_sky_dome__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__set_sky_dome__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__set_sky_dome__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__set_sky_dome__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__set_sky_dome__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__set_sky_dome__SWIG_0(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 13, "SceneManager._set_sky_dome", 
    "    void SceneManager._set_sky_dome(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._set_sky_dome(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._set_sky_dome(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._set_sky_dome(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._set_sky_dome(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._set_sky_dome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, Ogre::uint8 renderQueue)\n"
    "    void SceneManager._set_sky_dome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance)\n"
    "    void SceneManager._set_sky_dome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling)\n"
    "    void SceneManager._set_sky_dome(bool enable, Ogre::String const &materialName, Ogre::Real curvature)\n"
    "    void SceneManager._set_sky_dome(bool enable, Ogre::String const &materialName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_sky_dome_enabled

  call-seq:
    set_sky_dome_enabled(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_sky_dome_enabled(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);
  {
    try {
      (arg1)->setSkyDomeEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.is_sky_dome_enabled

  call-seq:
    is_sky_dome_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_is_sky_dome_enabled(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->isSkyDomeEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_sky_dome_node

  call-seq:
    get_sky_dome_node -> SceneNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_sky_dome_node(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);
  {
    try {
      result = (Ogre::SceneNode *)((Ogre::SceneManager const *)arg1)->getSkyDomeNode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_sky_dome_gen_parameters

  call-seq:
    get_sky_dome_gen_parameters -> SkyDomeGenParameters

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_sky_dome_gen_parameters(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);
  {
    try {
      result = (Ogre::SceneManager::SkyDomeGenParameters *) &((Ogre::SceneManager const *)arg1)->getSkyDomeGenParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager__SkyDomeGenParameters, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_fog

  call-seq:
    set_fog(FogMode mode=FOG_NONE, ColourValue colour=White, Real expDensity=0.001, 
    Real linearStart=0.0, Real linearEnd=1.0)
    set_fog(FogMode mode=FOG_NONE, ColourValue colour=White, Real expDensity=0.001, 
    Real linearStart=0.0)
    set_fog(FogMode mode=FOG_NONE, ColourValue colour=White, Real expDensity=0.001)
    set_fog(FogMode mode=FOG_NONE, ColourValue colour=White)
    set_fog(FogMode mode=FOG_NONE)
    set_fog

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2,(Ogre::ColourValue const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_fog__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);
  {
    try {
      (arg1)->setFog(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_fog__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);
  {
    try {
      (arg1)->setFog();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_set_fog(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_set_fog__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_set_fog__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_set_fog__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_set_fog__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_set_fog__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_set_fog__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "SceneManager.set_fog", 
    "    void SceneManager.set_fog(Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart, Ogre::Real linearEnd)\n"
    "    void SceneManager.set_fog(Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart)\n"
    "    void SceneManager.set_fog(Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity)\n"
    "    void SceneManager.set_fog(Ogre::FogMode mode, Ogre::ColourValue const &colour)\n"
    "    void SceneManager.set_fog(Ogre::FogMode mode)\n"
    "    void SceneManager.set_fog()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_fog_mode

  call-seq:
    get_fog_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_fog_mode(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);
  {
    try {
      result = (Ogre::FogMode)((Ogre::SceneManager const *)arg1)->getFogMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_fog_colour

  call-seq:
    get_fog_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_fog_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::SceneManager const *)arg1)->getFogColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_fog_start

  call-seq:
    get_fog_start -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_fog_start(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);
  {
    try {
      result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getFogStart();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_fog_end

  call-seq:
    get_fog_end -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_fog_end(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);
  {
    try {
      result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getFogEnd();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_fog_density

  call-seq:
    get_fog_density -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_fog_density(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);
  {
    try {
      result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getFogDensity();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_billboard_set

  call-seq:
    create_billboard_set(String name, unsigned int poolSize=20) -> BillboardSet
    create_billboard_set(String name) -> BillboardSet
    create_billboard_set(unsigned int poolSize=20) -> BillboardSet
    create_billboard_set -> BillboardSet

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_billboard_set__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);
  {
    try {
      result = (Ogre::BillboardSet *)(arg1)->createBillboardSet((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_billboard_set__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;
  }
  {
    try {
      result = (Ogre::BillboardSet *)(arg1)->createBillboardSet((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_billboard_set__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);
  {
    try {
      result = (Ogre::BillboardSet *)(arg1)->createBillboardSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_create_billboard_set__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);
  {
    try {
      result = (Ogre::BillboardSet *)(arg1)->createBillboardSet();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_create_billboard_set(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_create_billboard_set__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_create_billboard_set__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_create_billboard_set__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_create_billboard_set__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.create_billboard_set", 
    "    Ogre::BillboardSet * SceneManager.create_billboard_set(Ogre::String const &name, unsigned int poolSize)\n"
    "    Ogre::BillboardSet * SceneManager.create_billboard_set(Ogre::String const &name)\n"
    "    Ogre::BillboardSet * SceneManager.create_billboard_set(unsigned int poolSize)\n"
    "    Ogre::BillboardSet * SceneManager.create_billboard_set()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_billboard_set

  call-seq:
    get_billboard_set(String name) -> BillboardSet

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_billboard_set(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;
  }
  {
    try {
      result = (Ogre::BillboardSet *)((Ogre::SceneManager const *)arg1)->getBillboardSet((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_billboard_set

  call-seq:
    has_billboard_set(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_billboard_set(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasBillboardSet((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_billboard_set

  call-seq:
    destroy_billboard_set(BillboardSet set)
    destroy_billboard_set(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_billboard_set__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);
  {
    try {
      (arg1)->destroyBillboardSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroy_billboard_set__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;
  }
  {
    try {
      (arg1)->destroyBillboardSet((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_billboard_set(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_destroy_billboard_set__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_destroy_billboard_set__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroy_billboard_set", 
    "    void SceneManager.destroy_billboard_set(Ogre::BillboardSet *set)\n"
    "    void SceneManager.destroy_billboard_set(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_billboard_sets

  call-seq:
    destroy_all_billboard_sets

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_billboard_sets(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);
  {
    try {
      (arg1)->destroyAllBillboardSets();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_display_scene_nodes

  call-seq:
    set_display_scene_nodes(bool display)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_display_scene_nodes(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);
  {
    try {
      (arg1)->setDisplaySceneNodes(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_display_scene_nodes

  call-seq:
    get_display_scene_nodes -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_display_scene_nodes(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->getDisplaySceneNodes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_animation

  call-seq:
    create_animation(String name, Real length) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_animation(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);
  {
    try {
      result = (Ogre::Animation *)(arg1)->createAnimation((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_animation

  call-seq:
    get_animation(String name) -> Animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_animation(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;
  }
  {
    try {
      result = (Ogre::Animation *)((Ogre::SceneManager const *)arg1)->getAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_animation

  call-seq:
    has_animation(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_animation(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_animation

  call-seq:
    destroy_animation(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_animation(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;
  }
  {
    try {
      (arg1)->destroyAnimation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_animations

  call-seq:
    destroy_all_animations

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_animations(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);
  {
    try {
      (arg1)->destroyAllAnimations();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_animation_state

  call-seq:
    create_animation_state(String animName) -> AnimationState

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_animation_state(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;
  }
  {
    try {
      result = (Ogre::AnimationState *)(arg1)->createAnimationState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_animation_state

  call-seq:
    get_animation_state(String animName) -> AnimationState

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_animation_state(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;
  }
  {
    try {
      result = (Ogre::AnimationState *)((Ogre::SceneManager const *)arg1)->getAnimationState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_animation_state

  call-seq:
    has_animation_state(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_animation_state(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasAnimationState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_animation_state

  call-seq:
    destroy_animation_state(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_animation_state(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;
  }
  {
    try {
      (arg1)->destroyAnimationState((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_animation_states

  call-seq:
    destroy_all_animation_states

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_animation_states(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);
  {
    try {
      (arg1)->destroyAllAnimationStates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.manual_render

  call-seq:
    manual_render(RenderOperation rend, Pass pass, Viewport vp, Matrix4 worldMatrix, 
    Matrix4 viewMatrix, Matrix4 projMatrix, 
    bool doBeginEndFrame=false)
    manual_render(RenderOperation rend, Pass pass, Viewport vp, Matrix4 worldMatrix, 
    Matrix4 viewMatrix, Matrix4 projMatrix)
    manual_render(Renderable rend, Pass pass, Viewport vp, Matrix4 viewMatrix, 
    Matrix4 projMatrix, bool doBeginEndFrame=false, 
    bool lightScissoringClipping=true, 
    bool doLightIteration=true, LightList manualLightList=0)
    manual_render(Renderable rend, Pass pass, Viewport vp, Matrix4 viewMatrix, 
    Matrix4 projMatrix, bool doBeginEndFrame=false, 
    bool lightScissoringClipping=true, 
    bool doLightIteration=true)
    manual_render(Renderable rend, Pass pass, Viewport vp, Matrix4 viewMatrix, 
    Matrix4 projMatrix, bool doBeginEndFrame=false, 
    bool lightScissoringClipping=true)
    manual_render(Renderable rend, Pass pass, Viewport vp, Matrix4 viewMatrix, 
    Matrix4 projMatrix, bool doBeginEndFrame=false)
    manual_render(Renderable rend, Pass pass, Viewport vp, Matrix4 viewMatrix, 
    Matrix4 projMatrix)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_manual_render__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);
  {
    try {
      (arg1)->manualRender(arg2,arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6,(Ogre::Matrix4 const &)*arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manual_render__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);
  {
    try {
      (arg1)->manualRender(arg2,arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6,(Ogre::Matrix4 const &)*arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manual_render__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);
  {
    try {
      (arg1)->manualRender(arg2,(Ogre::Pass const *)arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6,arg7,arg8,arg9,(Ogre::LightList const *)arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manual_render__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);
  {
    try {
      (arg1)->manualRender(arg2,(Ogre::Pass const *)arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manual_render__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);
  {
    try {
      (arg1)->manualRender(arg2,(Ogre::Pass const *)arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manual_render__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);
  {
    try {
      (arg1)->manualRender(arg2,(Ogre::Pass const *)arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manual_render__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);
  {
    try {
      (arg1)->manualRender(arg2,(Ogre::Pass const *)arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_manual_render(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_manual_render__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_manual_render__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_manual_render__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_manual_render__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_manual_render__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_manual_render__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_manual_render__SWIG_2(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 11, "SceneManager.manual_render", 
    "    void SceneManager.manual_render(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.manual_render(Ogre::RenderOperation *rend, Ogre::Pass *pass, Ogre::Viewport *vp, Ogre::Matrix4 const &worldMatrix, Ogre::Matrix4 const &viewMatrix, Ogre::Matrix4 const &projMatrix)\n"
    "    void SceneManager.manual_render(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.manual_render(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.manual_render(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.manual_render(Ogre::Renderable *rend, Ogre::Pass const *pass, Ogre::Viewport *vp, Ogre::Matrix4 const &viewMatrix, Ogre::Matrix4 const &projMatrix, bool doBeginEndFrame)\n"
    "    void SceneManager.manual_render(Ogre::Renderable *rend, Ogre::Pass const *pass, Ogre::Viewport *vp, Ogre::Matrix4 const &viewMatrix, Ogre::Matrix4 const &projMatrix)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_render_queue

  call-seq:
    get_render_queue -> RenderQueue

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_render_queue(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);
  {
    try {
      result = (Ogre::RenderQueue *)(arg1)->getRenderQueue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.add_render_queue_listener

  call-seq:
    add_render_queue_listener(RenderQueueListener newListener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_add_render_queue_listener(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);
  {
    try {
      (arg1)->addRenderQueueListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.remove_render_queue_listener

  call-seq:
    remove_render_queue_listener(RenderQueueListener delListener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_remove_render_queue_listener(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);
  {
    try {
      (arg1)->removeRenderQueueListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.add_render_object_listener

  call-seq:
    add_render_object_listener(RenderObjectListener newListener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_add_render_object_listener(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);
  {
    try {
      (arg1)->addRenderObjectListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.remove_render_object_listener

  call-seq:
    remove_render_object_listener(RenderObjectListener delListener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_remove_render_object_listener(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);
  {
    try {
      (arg1)->removeRenderObjectListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.add_special_case_render_queue

  call-seq:
    add_special_case_render_queue(uint8 qid)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_add_special_case_render_queue(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);
  {
    try {
      (arg1)->addSpecialCaseRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.remove_special_case_render_queue

  call-seq:
    remove_special_case_render_queue(uint8 qid)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_remove_special_case_render_queue(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);
  {
    try {
      (arg1)->removeSpecialCaseRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.clear_special_case_render_queues

  call-seq:
    clear_special_case_render_queues

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_clear_special_case_render_queues(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);
  {
    try {
      (arg1)->clearSpecialCaseRenderQueues();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_special_case_render_queue_mode

  call-seq:
    set_special_case_render_queue_mode(SpecialCaseRenderQueueMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_special_case_render_queue_mode(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);
  {
    try {
      (arg1)->setSpecialCaseRenderQueueMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_special_case_render_queue_mode

  call-seq:
    get_special_case_render_queue_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_special_case_render_queue_mode(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);
  {
    try {
      result = (Ogre::SceneManager::SpecialCaseRenderQueueMode)(arg1)->getSpecialCaseRenderQueueMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.is_render_queue_to_be_processed

  call-seq:
    is_render_queue_to_be_processed(uint8 qid) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_is_render_queue_to_be_processed(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);
  {
    try {
      result = (bool)(arg1)->isRenderQueueToBeProcessed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_world_geometry_render_queue

  call-seq:
    set_world_geometry_render_queue(uint8 qid)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_world_geometry_render_queue(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);
  {
    try {
      (arg1)->setWorldGeometryRenderQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_world_geometry_render_queue

  call-seq:
    get_world_geometry_render_queue -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_world_geometry_render_queue(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);
  {
    try {
      result = (Ogre::uint8)(arg1)->getWorldGeometryRenderQueue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.show_bounding_boxes

  call-seq:
    show_bounding_boxes(bool bShow)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_show_bounding_boxes(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);
  {
    try {
      (arg1)->showBoundingBoxes(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_show_bounding_boxes

  call-seq:
    get_show_bounding_boxes -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_show_bounding_boxes(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->getShowBoundingBoxes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._notify_autotracking_scene_node

  call-seq:
    _notify_autotracking_scene_node(SceneNode node, bool autoTrack)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__notify_autotracking_scene_node(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);
  {
    try {
      (arg1)->_notifyAutotrackingSceneNode(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_aabbquery

  call-seq:
    create_aabbquery(AxisAlignedBox box, unsigned long mask=0xFFFFFFFF) -> AxisAlignedBoxSceneQuery
    create_aabbquery(AxisAlignedBox box) -> AxisAlignedBoxSceneQuery

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_aabbquery__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);
  {
    try {
      result = (Ogre::AxisAlignedBoxSceneQuery *)(arg1)->createAABBQuery((Ogre::AxisAlignedBox const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBoxSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_create_aabbquery__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);
  {
    try {
      result = (Ogre::AxisAlignedBoxSceneQuery *)(arg1)->createAABBQuery((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBoxSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_create_aabbquery(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_create_aabbquery__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_create_aabbquery__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.create_aabbquery", 
    "    Ogre::AxisAlignedBoxSceneQuery * SceneManager.create_aabbquery(Ogre::AxisAlignedBox const &box, unsigned long mask)\n"
    "    Ogre::AxisAlignedBoxSceneQuery * SceneManager.create_aabbquery(Ogre::AxisAlignedBox const &box)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_sphere_query

  call-seq:
    create_sphere_query(Sphere sphere, unsigned long mask=0xFFFFFFFF) -> SphereSceneQuery
    create_sphere_query(Sphere sphere) -> SphereSceneQuery

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_sphere_query__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);
  {
    try {
      result = (Ogre::SphereSceneQuery *)(arg1)->createSphereQuery((Ogre::Sphere const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SphereSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_create_sphere_query__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);
  {
    try {
      result = (Ogre::SphereSceneQuery *)(arg1)->createSphereQuery((Ogre::Sphere const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SphereSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_create_sphere_query(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_create_sphere_query__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_create_sphere_query__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.create_sphere_query", 
    "    Ogre::SphereSceneQuery * SceneManager.create_sphere_query(Ogre::Sphere const &sphere, unsigned long mask)\n"
    "    Ogre::SphereSceneQuery * SceneManager.create_sphere_query(Ogre::Sphere const &sphere)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_plane_bounded_volume_query

  call-seq:
    create_plane_bounded_volume_query(PlaneBoundedVolumeList volumes, unsigned long mask=0xFFFFFFFF) -> PlaneBoundedVolumeListSceneQuery
    create_plane_bounded_volume_query(PlaneBoundedVolumeList volumes) -> PlaneBoundedVolumeListSceneQuery

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_plane_bounded_volume_query__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);
  {
    try {
      result = (Ogre::PlaneBoundedVolumeListSceneQuery *)(arg1)->createPlaneBoundedVolumeQuery((Ogre::PlaneBoundedVolumeList const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PlaneBoundedVolumeListSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_create_plane_bounded_volume_query__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);
  {
    try {
      result = (Ogre::PlaneBoundedVolumeListSceneQuery *)(arg1)->createPlaneBoundedVolumeQuery((Ogre::PlaneBoundedVolumeList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PlaneBoundedVolumeListSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_create_plane_bounded_volume_query(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_create_plane_bounded_volume_query__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_create_plane_bounded_volume_query__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.create_plane_bounded_volume_query", 
    "    Ogre::PlaneBoundedVolumeListSceneQuery * SceneManager.create_plane_bounded_volume_query(Ogre::PlaneBoundedVolumeList const &volumes, unsigned long mask)\n"
    "    Ogre::PlaneBoundedVolumeListSceneQuery * SceneManager.create_plane_bounded_volume_query(Ogre::PlaneBoundedVolumeList const &volumes)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_ray_query

  call-seq:
    create_ray_query(Ray ray, unsigned long mask=0xFFFFFFFF) -> RaySceneQuery
    create_ray_query(Ray ray) -> RaySceneQuery

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_ray_query__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);
  {
    try {
      result = (Ogre::RaySceneQuery *)(arg1)->createRayQuery((Ogre::Ray const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RaySceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_create_ray_query__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);
  {
    try {
      result = (Ogre::RaySceneQuery *)(arg1)->createRayQuery((Ogre::Ray const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RaySceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_create_ray_query(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_create_ray_query__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_create_ray_query__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.create_ray_query", 
    "    Ogre::RaySceneQuery * SceneManager.create_ray_query(Ogre::Ray const &ray, unsigned long mask)\n"
    "    Ogre::RaySceneQuery * SceneManager.create_ray_query(Ogre::Ray const &ray)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_intersection_query

  call-seq:
    create_intersection_query(unsigned long mask=0xFFFFFFFF) -> IntersectionSceneQuery
    create_intersection_query -> IntersectionSceneQuery

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_intersection_query__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);
  {
    try {
      result = (Ogre::IntersectionSceneQuery *)(arg1)->createIntersectionQuery(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__IntersectionSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_create_intersection_query__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);
  {
    try {
      result = (Ogre::IntersectionSceneQuery *)(arg1)->createIntersectionQuery();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__IntersectionSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_create_intersection_query(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_create_intersection_query__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_create_intersection_query__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.create_intersection_query", 
    "    Ogre::IntersectionSceneQuery * SceneManager.create_intersection_query(unsigned long mask)\n"
    "    Ogre::IntersectionSceneQuery * SceneManager.create_intersection_query()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_query

  call-seq:
    destroy_query(SceneQuery query)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_query(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);
  {
    try {
      (arg1)->destroyQuery(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_camera_iterator

  call-seq:
    get_camera_iterator -> CameraIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_camera_iterator(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);
  {
    try {
      result = (arg1)->getCameraIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::SceneManager::CameraIterator(static_cast< const Ogre::SceneManager::CameraIterator& >(result))), SWIGTYPE_p_Ogre__SceneManager__CameraIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_animation_iterator

  call-seq:
    get_animation_iterator -> AnimationIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_animation_iterator(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);
  {
    try {
      result = (arg1)->getAnimationIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::SceneManager::AnimationIterator(static_cast< const Ogre::SceneManager::AnimationIterator& >(result))), SWIGTYPE_p_Ogre__SceneManager__AnimationIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_animation_state_iterator

  call-seq:
    get_animation_state_iterator -> AnimationStateIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_animation_state_iterator(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);
  {
    try {
      result = (arg1)->getAnimationStateIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::AnimationStateIterator(static_cast< const Ogre::AnimationStateIterator& >(result))), SWIGTYPE_p_Ogre__AnimationStateIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_technique

  call-seq:
    set_shadow_technique(ShadowTechnique technique)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_technique(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);
  {
    try {
      (arg1)->setShadowTechnique(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_technique

  call-seq:
    get_shadow_technique -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_technique(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);
  {
    try {
      result = (Ogre::ShadowTechnique)((Ogre::SceneManager const *)arg1)->getShadowTechnique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_show_debug_shadows

  call-seq:
    set_show_debug_shadows(bool debug)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_show_debug_shadows(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);
  {
    try {
      (arg1)->setShowDebugShadows(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_show_debug_shadows

  call-seq:
    get_show_debug_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_show_debug_shadows(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->getShowDebugShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_colour

  call-seq:
    set_shadow_colour(ColourValue colour)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_colour(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);
  {
    try {
      (arg1)->setShadowColour((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_colour

  call-seq:
    get_shadow_colour -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_colour(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);
  {
    try {
      result = (Ogre::ColourValue *) &((Ogre::SceneManager const *)arg1)->getShadowColour();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_directional_light_extrusion_distance

  call-seq:
    set_shadow_directional_light_extrusion_distance(Real dist)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_directional_light_extrusion_distance(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);
  {
    try {
      (arg1)->setShadowDirectionalLightExtrusionDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_directional_light_extrusion_distance

  call-seq:
    get_shadow_directional_light_extrusion_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_directional_light_extrusion_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getShadowDirectionalLightExtrusionDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_far_distance

  call-seq:
    set_shadow_far_distance(Real distance)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_far_distance(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);
  {
    try {
      (arg1)->setShadowFarDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_far_distance

  call-seq:
    get_shadow_far_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_far_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getShadowFarDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_far_distance_squared

  call-seq:
    get_shadow_far_distance_squared -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_far_distance_squared(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);
  {
    try {
      result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getShadowFarDistanceSquared();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_index_buffer_size

  call-seq:
    set_shadow_index_buffer_size(size_t size)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_index_buffer_size(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);
  {
    try {
      (arg1)->setShadowIndexBufferSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_index_buffer_size

  call-seq:
    get_shadow_index_buffer_size -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_index_buffer_size(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);
  {
    try {
      result = ((Ogre::SceneManager const *)arg1)->getShadowIndexBufferSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_texture_size

  call-seq:
    set_shadow_texture_size(unsigned short size)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_size(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);
  {
    try {
      (arg1)->setShadowTextureSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_texture_config

  call-seq:
    set_shadow_texture_config(size_t shadowIndex, unsigned short width, unsigned short height, 
    PixelFormat format, unsigned short fsaa=0, 
    uint16 depthBufferPoolId=1)
    set_shadow_texture_config(size_t shadowIndex, unsigned short width, unsigned short height, 
    PixelFormat format, unsigned short fsaa=0)
    set_shadow_texture_config(size_t shadowIndex, unsigned short width, unsigned short height, 
    PixelFormat format)
    set_shadow_texture_config(size_t shadowIndex, ShadowTextureConfig config)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_config__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);
  {
    try {
      (arg1)->setShadowTextureConfig(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_config__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);
  {
    try {
      (arg1)->setShadowTextureConfig(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_config__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);
  {
    try {
      (arg1)->setShadowTextureConfig(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_config__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);
  {
    try {
      (arg1)->setShadowTextureConfig(arg2,(Ogre::ShadowTextureConfig const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_set_shadow_texture_config(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_set_shadow_texture_config__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_set_shadow_texture_config__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_set_shadow_texture_config__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_set_shadow_texture_config__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "SceneManager.set_shadow_texture_config", 
    "    void SceneManager.set_shadow_texture_config(size_t shadowIndex, unsigned short width, unsigned short height, Ogre::PixelFormat format, unsigned short fsaa, Ogre::uint16 depthBufferPoolId)\n"
    "    void SceneManager.set_shadow_texture_config(size_t shadowIndex, unsigned short width, unsigned short height, Ogre::PixelFormat format, unsigned short fsaa)\n"
    "    void SceneManager.set_shadow_texture_config(size_t shadowIndex, unsigned short width, unsigned short height, Ogre::PixelFormat format)\n"
    "    void SceneManager.set_shadow_texture_config(size_t shadowIndex, Ogre::ShadowTextureConfig const &config)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_texture_config_iterator

  call-seq:
    get_shadow_texture_config_iterator -> ConstShadowTextureConfigIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_texture_config_iterator(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);
  {
    try {
      result = ((Ogre::SceneManager const *)arg1)->getShadowTextureConfigIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::ConstShadowTextureConfigIterator(static_cast< const Ogre::ConstShadowTextureConfigIterator& >(result))), SWIGTYPE_p_Ogre__ConstShadowTextureConfigIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_texture_pixel_format

  call-seq:
    set_shadow_texture_pixel_format(PixelFormat fmt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_pixel_format(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);
  {
    try {
      (arg1)->setShadowTexturePixelFormat(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_texture_fsaa

  call-seq:
    set_shadow_texture_fsaa(unsigned short fsaa)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_fsaa(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);
  {
    try {
      (arg1)->setShadowTextureFSAA(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_texture_count

  call-seq:
    set_shadow_texture_count(size_t count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_count(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);
  {
    try {
      (arg1)->setShadowTextureCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_texture_count

  call-seq:
    get_shadow_texture_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_texture_count(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);
  {
    try {
      result = ((Ogre::SceneManager const *)arg1)->getShadowTextureCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_texture_count_per_light_type

  call-seq:
    set_shadow_texture_count_per_light_type(LightTypes type, size_t count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_count_per_light_type(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);
  {
    try {
      (arg1)->setShadowTextureCountPerLightType(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_texture_count_per_light_type

  call-seq:
    get_shadow_texture_count_per_light_type(LightTypes type) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_texture_count_per_light_type(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);
  {
    try {
      result = ((Ogre::SceneManager const *)arg1)->getShadowTextureCountPerLightType(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_texture_settings

  call-seq:
    set_shadow_texture_settings(unsigned short size, unsigned short count, PixelFormat fmt=PF_X8R8G8B8, 
    unsigned short fsaa=0, uint16 depthBufferPoolId=1)
    set_shadow_texture_settings(unsigned short size, unsigned short count, PixelFormat fmt=PF_X8R8G8B8, 
    unsigned short fsaa=0)
    set_shadow_texture_settings(unsigned short size, unsigned short count, PixelFormat fmt=PF_X8R8G8B8)
    set_shadow_texture_settings(unsigned short size, unsigned short count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_settings__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);
  {
    try {
      (arg1)->setShadowTextureSettings(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_settings__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);
  {
    try {
      (arg1)->setShadowTextureSettings(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_settings__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);
  {
    try {
      (arg1)->setShadowTextureSettings(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_settings__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);
  {
    try {
      (arg1)->setShadowTextureSettings(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_set_shadow_texture_settings(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_set_shadow_texture_settings__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_set_shadow_texture_settings__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_set_shadow_texture_settings__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_set_shadow_texture_settings__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "SceneManager.set_shadow_texture_settings", 
    "    void SceneManager.set_shadow_texture_settings(unsigned short size, unsigned short count, Ogre::PixelFormat fmt, unsigned short fsaa, Ogre::uint16 depthBufferPoolId)\n"
    "    void SceneManager.set_shadow_texture_settings(unsigned short size, unsigned short count, Ogre::PixelFormat fmt, unsigned short fsaa)\n"
    "    void SceneManager.set_shadow_texture_settings(unsigned short size, unsigned short count, Ogre::PixelFormat fmt)\n"
    "    void SceneManager.set_shadow_texture_settings(unsigned short size, unsigned short count)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_texture

  call-seq:
    get_shadow_texture(size_t shadowIndex) -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_texture(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);
  {
    try {
      result = (Ogre::TexturePtr *) &(arg1)->getShadowTexture(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_dir_light_texture_offset

  call-seq:
    set_shadow_dir_light_texture_offset(Real offset)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_dir_light_texture_offset(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);
  {
    try {
      (arg1)->setShadowDirLightTextureOffset(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_dir_light_texture_offset

  call-seq:
    get_shadow_dir_light_texture_offset -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_dir_light_texture_offset(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);
  {
    try {
      result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getShadowDirLightTextureOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_texture_fade_start

  call-seq:
    set_shadow_texture_fade_start(Real fadeStart)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_fade_start(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);
  {
    try {
      (arg1)->setShadowTextureFadeStart(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_texture_fade_end

  call-seq:
    set_shadow_texture_fade_end(Real fadeEnd)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_fade_end(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);
  {
    try {
      (arg1)->setShadowTextureFadeEnd(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_texture_self_shadow

  call-seq:
    set_shadow_texture_self_shadow(bool selfShadow)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_self_shadow(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);
  {
    try {
      (arg1)->setShadowTextureSelfShadow(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_texture_self_shadow

  call-seq:
    get_shadow_texture_self_shadow -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_texture_self_shadow(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->getShadowTextureSelfShadow();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_texture_caster_material

  call-seq:
    set_shadow_texture_caster_material(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_caster_material(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;
  }
  {
    try {
      (arg1)->setShadowTextureCasterMaterial((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_texture_receiver_material

  call-seq:
    set_shadow_texture_receiver_material(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_texture_receiver_material(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;
  }
  {
    try {
      (arg1)->setShadowTextureReceiverMaterial((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_caster_render_back_faces

  call-seq:
    set_shadow_caster_render_back_faces(bool bf)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_caster_render_back_faces(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);
  {
    try {
      (arg1)->setShadowCasterRenderBackFaces(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_caster_render_back_faces

  call-seq:
    get_shadow_caster_render_back_faces -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_caster_render_back_faces(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->getShadowCasterRenderBackFaces();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_camera_setup

  call-seq:
    set_shadow_camera_setup(ShadowCameraSetupPtr shadowSetup)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_camera_setup(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);
  {
    try {
      (arg1)->setShadowCameraSetup((Ogre::ShadowCameraSetupPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_camera_setup

  call-seq:
    get_shadow_camera_setup -> ShadowCameraSetupPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_camera_setup(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);
  {
    try {
      result = (Ogre::ShadowCameraSetupPtr *) &((Ogre::SceneManager const *)arg1)->getShadowCameraSetup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_use_infinite_far_plane

  call-seq:
    set_shadow_use_infinite_far_plane(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_use_infinite_far_plane(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);
  {
    try {
      (arg1)->setShadowUseInfiniteFarPlane(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.is_shadow_technique_stencil_based

  call-seq:
    is_shadow_technique_stencil_based -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_is_shadow_technique_stencil_based(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->isShadowTechniqueStencilBased();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.is_shadow_technique_texture_based

  call-seq:
    is_shadow_technique_texture_based -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_is_shadow_technique_texture_based(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->isShadowTechniqueTextureBased();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.is_shadow_technique_modulative

  call-seq:
    is_shadow_technique_modulative -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_is_shadow_technique_modulative(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->isShadowTechniqueModulative();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.is_shadow_technique_additive

  call-seq:
    is_shadow_technique_additive -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_is_shadow_technique_additive(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->isShadowTechniqueAdditive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.is_shadow_technique_integrated

  call-seq:
    is_shadow_technique_integrated -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_is_shadow_technique_integrated(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->isShadowTechniqueIntegrated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.is_shadow_technique_in_use

  call-seq:
    is_shadow_technique_in_use -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_is_shadow_technique_in_use(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->isShadowTechniqueInUse();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_shadow_use_light_clip_planes

  call-seq:
    set_shadow_use_light_clip_planes(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_shadow_use_light_clip_planes(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);
  {
    try {
      (arg1)->setShadowUseLightClipPlanes(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_use_light_clip_planes

  call-seq:
    get_shadow_use_light_clip_planes -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_use_light_clip_planes(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->getShadowUseLightClipPlanes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._set_active_compositor_chain

  call-seq:
    _set_active_compositor_chain(CompositorChain chain)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__set_active_compositor_chain(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);
  {
    try {
      (arg1)->_setActiveCompositorChain(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_late_material_resolving

  call-seq:
    set_late_material_resolving(bool isLate)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_late_material_resolving(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);
  {
    try {
      (arg1)->setLateMaterialResolving(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.is_late_material_resolving

  call-seq:
    is_late_material_resolving -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_is_late_material_resolving(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->isLateMaterialResolving();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._get_active_compositor_chain

  call-seq:
    _get_active_compositor_chain -> CompositorChain

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__get_active_compositor_chain(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);
  {
    try {
      result = (Ogre::CompositorChain *)((Ogre::SceneManager const *)arg1)->_getActiveCompositorChain();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorChain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.add_listener

  call-seq:
    add_listener(Listener s)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_add_listener(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);
  {
    try {
      (arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.remove_listener

  call-seq:
    remove_listener(Listener s)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_remove_listener(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);
  {
    try {
      (arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_static_geometry

  call-seq:
    create_static_geometry(String name) -> StaticGeometry

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_static_geometry(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;
  }
  {
    try {
      result = (Ogre::StaticGeometry *)(arg1)->createStaticGeometry((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StaticGeometry, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_static_geometry

  call-seq:
    get_static_geometry(String name) -> StaticGeometry

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_static_geometry(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;
  }
  {
    try {
      result = (Ogre::StaticGeometry *)((Ogre::SceneManager const *)arg1)->getStaticGeometry((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StaticGeometry, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_static_geometry

  call-seq:
    has_static_geometry(String name) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_static_geometry(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasStaticGeometry((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_static_geometry

  call-seq:
    destroy_static_geometry(StaticGeometry geom)
    destroy_static_geometry(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_static_geometry__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);
  {
    try {
      (arg1)->destroyStaticGeometry(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroy_static_geometry__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;
  }
  {
    try {
      (arg1)->destroyStaticGeometry((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_static_geometry(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_destroy_static_geometry__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_destroy_static_geometry__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroy_static_geometry", 
    "    void SceneManager.destroy_static_geometry(Ogre::StaticGeometry *geom)\n"
    "    void SceneManager.destroy_static_geometry(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_static_geometry

  call-seq:
    destroy_all_static_geometry

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_static_geometry(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);
  {
    try {
      (arg1)->destroyAllStaticGeometry();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_instanced_geometry

  call-seq:
    create_instanced_geometry(String name) -> InstancedGeometry

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_instanced_geometry(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;
  }
  {
    try {
      result = (Ogre::InstancedGeometry *)(arg1)->createInstancedGeometry((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstancedGeometry, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_instanced_geometry

  call-seq:
    get_instanced_geometry(String name) -> InstancedGeometry

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_instanced_geometry(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;
  }
  {
    try {
      result = (Ogre::InstancedGeometry *)((Ogre::SceneManager const *)arg1)->getInstancedGeometry((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstancedGeometry, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_instanced_geometry

  call-seq:
    destroy_instanced_geometry(InstancedGeometry geom)
    destroy_instanced_geometry(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_instanced_geometry__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);
  {
    try {
      (arg1)->destroyInstancedGeometry(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroy_instanced_geometry__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;
  }
  {
    try {
      (arg1)->destroyInstancedGeometry((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_instanced_geometry(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_destroy_instanced_geometry__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_destroy_instanced_geometry__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroy_instanced_geometry", 
    "    void SceneManager.destroy_instanced_geometry(Ogre::InstancedGeometry *geom)\n"
    "    void SceneManager.destroy_instanced_geometry(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_instanced_geometry

  call-seq:
    destroy_all_instanced_geometry

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_instanced_geometry(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);
  {
    try {
      (arg1)->destroyAllInstancedGeometry();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_instance_manager

  call-seq:
    create_instance_manager(String customName, String meshName, String groupName, 
    InstancingTechnique technique, size_t numInstancesPerBatch, 
    uint16 flags=0, unsigned short subMeshIdx=0) -> InstanceManager
    create_instance_manager(String customName, String meshName, String groupName, 
    InstancingTechnique technique, size_t numInstancesPerBatch, 
    uint16 flags=0) -> InstanceManager
    create_instance_manager(String customName, String meshName, String groupName, 
    InstancingTechnique technique, size_t numInstancesPerBatch) -> InstanceManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_instance_manager__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);
  {
    try {
      result = (Ogre::InstanceManager *)(arg1)->createInstanceManager((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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_create_instance_manager__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);
  {
    try {
      result = (Ogre::InstanceManager *)(arg1)->createInstanceManager((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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_create_instance_manager__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);
  {
    try {
      result = (Ogre::InstanceManager *)(arg1)->createInstanceManager((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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_create_instance_manager(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_create_instance_manager__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_create_instance_manager__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_create_instance_manager__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "SceneManager.create_instance_manager", 
    "    Ogre::InstanceManager * SceneManager.create_instance_manager(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.create_instance_manager(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.create_instance_manager(Ogre::String const &customName, Ogre::String const &meshName, Ogre::String const &groupName, Ogre::InstanceManager::InstancingTechnique technique, size_t numInstancesPerBatch)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_instance_manager

  call-seq:
    get_instance_manager(String managerName) -> InstanceManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_instance_manager(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;
  }
  {
    try {
      result = (Ogre::InstanceManager *)((Ogre::SceneManager const *)arg1)->getInstanceManager((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstanceManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.has_instance_manager

  call-seq:
    has_instance_manager(String managerName) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_instance_manager(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasInstanceManager((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_instance_manager

  call-seq:
    destroy_instance_manager(String name)
    destroy_instance_manager(InstanceManager instanceManager)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_instance_manager__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;
  }
  {
    try {
      (arg1)->destroyInstanceManager((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroy_instance_manager__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);
  {
    try {
      (arg1)->destroyInstanceManager(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_instance_manager(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_destroy_instance_manager__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_destroy_instance_manager__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroy_instance_manager", 
    "    void SceneManager.destroy_instance_manager(Ogre::String const &name)\n"
    "    void SceneManager.destroy_instance_manager(Ogre::InstanceManager *instanceManager)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_instance_managers

  call-seq:
    destroy_all_instance_managers

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_instance_managers(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);
  {
    try {
      (arg1)->destroyAllInstanceManagers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_num_instances_per_batch

  call-seq:
    get_num_instances_per_batch(String meshName, String groupName, String materialName, 
    InstancingTechnique technique, size_t numInstancesPerBatch, 
    uint16 flags=0, unsigned short subMeshIdx=0) -> size_t
    get_num_instances_per_batch(String meshName, String groupName, String materialName, 
    InstancingTechnique technique, size_t numInstancesPerBatch, 
    uint16 flags=0) -> size_t
    get_num_instances_per_batch(String meshName, String groupName, String materialName, 
    InstancingTechnique technique, size_t numInstancesPerBatch) -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_num_instances_per_batch__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);
  {
    try {
      result = (arg1)->getNumInstancesPerBatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  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_get_num_instances_per_batch__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);
  {
    try {
      result = (arg1)->getNumInstancesPerBatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  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_get_num_instances_per_batch__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);
  {
    try {
      result = (arg1)->getNumInstancesPerBatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  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_get_num_instances_per_batch(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_get_num_instances_per_batch__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_get_num_instances_per_batch__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_get_num_instances_per_batch__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "SceneManager.get_num_instances_per_batch", 
    "    size_t SceneManager.get_num_instances_per_batch(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.get_num_instances_per_batch(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.get_num_instances_per_batch(Ogre::String const &meshName, Ogre::String const &groupName, Ogre::String const &materialName, Ogre::InstanceManager::InstancingTechnique technique, size_t numInstancesPerBatch)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_instanced_entity

  call-seq:
    create_instanced_entity(String materialName, String managerName) -> InstancedEntity

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_instanced_entity(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;
  }
  {
    try {
      result = (Ogre::InstancedEntity *)(arg1)->createInstancedEntity((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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;
}



/*
  Document-method: Ogre::SceneManager.destroy_instanced_entity

  call-seq:
    destroy_instanced_entity(InstancedEntity instancedEntity)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_instanced_entity(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);
  {
    try {
      (arg1)->destroyInstancedEntity(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._add_dirty_instance_manager

  call-seq:
    _add_dirty_instance_manager(InstanceManager dirtyManager)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__add_dirty_instance_manager(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);
  {
    try {
      (arg1)->_addDirtyInstanceManager(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_movable_object

  call-seq:
    create_movable_object(String name, String typeName, NameValuePairList params=0) -> MovableObject
    create_movable_object(String name, String typeName) -> MovableObject
    create_movable_object(String typeName, NameValuePairList params=0) -> MovableObject
    create_movable_object(String typeName) -> MovableObject
    create_movable_object(String name, String typeName, VALUE params) -> MovableObject
    create_movable_object(String typeName, VALUE params) -> MovableObject

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_movable_object__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);
  {
    try {
      result = (Ogre::MovableObject *)(arg1)->createMovableObject((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::NameValuePairList const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_movable_object__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;
  }
  {
    try {
      result = (Ogre::MovableObject *)(arg1)->createMovableObject((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_create_movable_object__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);
  {
    try {
      result = (Ogre::MovableObject *)(arg1)->createMovableObject((Ogre::String const &)*arg2,(Ogre::NameValuePairList const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_movable_object__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;
  }
  {
    try {
      result = (Ogre::MovableObject *)(arg1)->createMovableObject((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_movable_object

  call-seq:
    destroy_movable_object(String name, String typeName)
    destroy_movable_object(MovableObject m)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_movable_object__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;
  }
  {
    try {
      (arg1)->destroyMovableObject((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_destroy_movable_object__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);
  {
    try {
      (arg1)->destroyMovableObject(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroy_movable_object(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_destroy_movable_object__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_destroy_movable_object__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.destroy_movable_object", 
    "    void SceneManager.destroy_movable_object(Ogre::String const &name, Ogre::String const &typeName)\n"
    "    void SceneManager.destroy_movable_object(Ogre::MovableObject *m)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_movable_objects_by_type

  call-seq:
    destroy_all_movable_objects_by_type(String typeName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_movable_objects_by_type(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;
  }
  {
    try {
      (arg1)->destroyAllMovableObjectsByType((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.destroy_all_movable_objects

  call-seq:
    destroy_all_movable_objects

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_destroy_all_movable_objects(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);
  {
    try {
      (arg1)->destroyAllMovableObjects();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_movable_object

  call-seq:
    get_movable_object(String name, String typeName) -> MovableObject

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_movable_object(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;
  }
  {
    try {
      result = (Ogre::MovableObject *)((Ogre::SceneManager const *)arg1)->getMovableObject((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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;
}



/*
  Document-method: Ogre::SceneManager.has_movable_object

  call-seq:
    has_movable_object(String name, String typeName) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_has_movable_object(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->hasMovableObject((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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;
}



/*
  Document-method: Ogre::SceneManager.get_movable_object_iterator

  call-seq:
    get_movable_object_iterator(String typeName) -> MovableObjectIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_movable_object_iterator(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;
  }
  {
    try {
      result = (arg1)->getMovableObjectIterator((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::SceneManager.inject_movable_object

  call-seq:
    inject_movable_object(MovableObject m)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_inject_movable_object(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);
  {
    try {
      (arg1)->injectMovableObject(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.extract_movable_object

  call-seq:
    extract_movable_object(String name, String typeName)
    extract_movable_object(MovableObject m)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_extract_movable_object__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;
  }
  {
    try {
      (arg1)->extractMovableObject((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_extract_movable_object__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);
  {
    try {
      (arg1)->extractMovableObject(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_extract_movable_object(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_extract_movable_object__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_extract_movable_object__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.extract_movable_object", 
    "    void SceneManager.extract_movable_object(Ogre::String const &name, Ogre::String const &typeName)\n"
    "    void SceneManager.extract_movable_object(Ogre::MovableObject *m)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.extract_all_movable_objects_by_type

  call-seq:
    extract_all_movable_objects_by_type(String typeName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_extract_all_movable_objects_by_type(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;
  }
  {
    try {
      (arg1)->extractAllMovableObjectsByType((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_visibility_mask

  call-seq:
    set_visibility_mask(uint32 vmask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_visibility_mask(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);
  {
    try {
      (arg1)->setVisibilityMask(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_visibility_mask

  call-seq:
    get_visibility_mask -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_visibility_mask(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);
  {
    try {
      result = (Ogre::uint32)(arg1)->getVisibilityMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._get_combined_visibility_mask

  call-seq:
    _get_combined_visibility_mask -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__get_combined_visibility_mask(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::SceneManager const *)arg1)->_getCombinedVisibilityMask();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_find_visible_objects

  call-seq:
    set_find_visible_objects(bool find)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_find_visible_objects(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);
  {
    try {
      (arg1)->setFindVisibleObjects(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_find_visible_objects

  call-seq:
    get_find_visible_objects -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_find_visible_objects(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);
  {
    try {
      result = (bool)(arg1)->getFindVisibleObjects();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_normalise_normals_on_scale

  call-seq:
    set_normalise_normals_on_scale(bool n)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_normalise_normals_on_scale(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);
  {
    try {
      (arg1)->setNormaliseNormalsOnScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_normalise_normals_on_scale

  call-seq:
    get_normalise_normals_on_scale -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_normalise_normals_on_scale(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->getNormaliseNormalsOnScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_flip_culling_on_negative_scale

  call-seq:
    set_flip_culling_on_negative_scale(bool n)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_flip_culling_on_negative_scale(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);
  {
    try {
      (arg1)->setFlipCullingOnNegativeScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_flip_culling_on_negative_scale

  call-seq:
    get_flip_culling_on_negative_scale -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_flip_culling_on_negative_scale(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->getFlipCullingOnNegativeScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._inject_render_with_pass

  call-seq:
    _inject_render_with_pass(Pass pass, Renderable rend, bool shadowDerivation=true, 
    bool doLightIteration=false, LightList manualLightList=0)
    _inject_render_with_pass(Pass pass, Renderable rend, bool shadowDerivation=true, 
    bool doLightIteration=false)
    _inject_render_with_pass(Pass pass, Renderable rend, bool shadowDerivation=true)
    _inject_render_with_pass(Pass pass, Renderable rend)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__inject_render_with_pass__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);
  {
    try {
      (arg1)->_injectRenderWithPass(arg2,arg3,arg4,arg5,(Ogre::LightList const *)arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__inject_render_with_pass__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);
  {
    try {
      (arg1)->_injectRenderWithPass(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__inject_render_with_pass__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);
  {
    try {
      (arg1)->_injectRenderWithPass(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__inject_render_with_pass__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);
  {
    try {
      (arg1)->_injectRenderWithPass(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager__inject_render_with_pass(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__inject_render_with_pass__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__inject_render_with_pass__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__inject_render_with_pass__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__inject_render_with_pass__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "SceneManager._inject_render_with_pass", 
    "    void SceneManager._inject_render_with_pass(Ogre::Pass *pass, Ogre::Renderable *rend, bool shadowDerivation, bool doLightIteration, Ogre::LightList const *manualLightList)\n"
    "    void SceneManager._inject_render_with_pass(Ogre::Pass *pass, Ogre::Renderable *rend, bool shadowDerivation, bool doLightIteration)\n"
    "    void SceneManager._inject_render_with_pass(Ogre::Pass *pass, Ogre::Renderable *rend, bool shadowDerivation)\n"
    "    void SceneManager._inject_render_with_pass(Ogre::Pass *pass, Ogre::Renderable *rend)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._suppress_render_state_changes

  call-seq:
    _suppress_render_state_changes(bool suppress)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__suppress_render_state_changes(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);
  {
    try {
      (arg1)->_suppressRenderStateChanges(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._are_render_state_changes_suppressed

  call-seq:
    _are_render_state_changes_suppressed -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__are_render_state_changes_suppressed(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->_areRenderStateChangesSuppressed();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._set_pass

  call-seq:
    _set_pass(Pass pass, bool evenIfSuppressed=false, bool shadowDerivation=true) -> Pass
    _set_pass(Pass pass, bool evenIfSuppressed=false) -> Pass
    _set_pass(Pass pass) -> Pass

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__set_pass__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);
  {
    try {
      result = (Ogre::Pass *)(arg1)->_setPass((Ogre::Pass const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_pass__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);
  {
    try {
      result = (Ogre::Pass *)(arg1)->_setPass((Ogre::Pass const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__set_pass__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);
  {
    try {
      result = (Ogre::Pass *)(arg1)->_setPass((Ogre::Pass const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager__set_pass(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__set_pass__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__set_pass__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__set_pass__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneManager._set_pass", 
    "    Ogre::Pass const * SceneManager._set_pass(Ogre::Pass const *pass, bool evenIfSuppressed, bool shadowDerivation)\n"
    "    Ogre::Pass const * SceneManager._set_pass(Ogre::Pass const *pass, bool evenIfSuppressed)\n"
    "    Ogre::Pass const * SceneManager._set_pass(Ogre::Pass const *pass)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._mark_gpu_params_dirty

  call-seq:
    _mark_gpu_params_dirty(uint16 mask)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__mark_gpu_params_dirty(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);
  {
    try {
      (arg1)->_markGpuParamsDirty(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._suppress_shadows

  call-seq:
    _suppress_shadows(bool suppress)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__suppress_shadows(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);
  {
    try {
      (arg1)->_suppressShadows(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._are_shadows_suppressed

  call-seq:
    _are_shadows_suppressed -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__are_shadows_suppressed(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->_areShadowsSuppressed();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._render_queue_group_objects

  call-seq:
    _render_queue_group_objects(RenderQueueGroup group, OrganisationMode om)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__render_queue_group_objects(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);
  {
    try {
      (arg1)->_renderQueueGroupObjects(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_queued_renderable_visitor

  call-seq:
    set_queued_renderable_visitor(SceneMgrQueuedRenderableVisitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_queued_renderable_visitor(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);
  {
    try {
      (arg1)->setQueuedRenderableVisitor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_queued_renderable_visitor

  call-seq:
    get_queued_renderable_visitor -> SceneMgrQueuedRenderableVisitor

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_queued_renderable_visitor(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);
  {
    try {
      result = (Ogre::SceneManager::SceneMgrQueuedRenderableVisitor *)((Ogre::SceneManager const *)arg1)->getQueuedRenderableVisitor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager__SceneMgrQueuedRenderableVisitor, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_destination_render_system

  call-seq:
    get_destination_render_system -> RenderSystem

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_destination_render_system(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);
  {
    try {
      result = (Ogre::RenderSystem *)(arg1)->getDestinationRenderSystem();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_current_viewport

  call-seq:
    get_current_viewport -> Viewport

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_current_viewport(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);
  {
    try {
      result = (Ogre::Viewport *)((Ogre::SceneManager const *)arg1)->getCurrentViewport();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_visible_objects_bounds_info

  call-seq:
    get_visible_objects_bounds_info(Camera cam) -> VisibleObjectsBoundsInfo

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_visible_objects_bounds_info(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);
  {
    try {
      result = (Ogre::VisibleObjectsBoundsInfo *) &((Ogre::SceneManager const *)arg1)->getVisibleObjectsBoundsInfo((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_shadow_caster_bounds_info

  call-seq:
    get_shadow_caster_bounds_info(Light light, size_t iteration=0) -> VisibleObjectsBoundsInfo
    get_shadow_caster_bounds_info(Light light) -> VisibleObjectsBoundsInfo

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_caster_bounds_info__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);
  {
    try {
      result = (Ogre::VisibleObjectsBoundsInfo *) &((Ogre::SceneManager const *)arg1)->getShadowCasterBoundsInfo((Ogre::Light const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_get_shadow_caster_bounds_info__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);
  {
    try {
      result = (Ogre::VisibleObjectsBoundsInfo *) &((Ogre::SceneManager const *)arg1)->getShadowCasterBoundsInfo((Ogre::Light const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_get_shadow_caster_bounds_info(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_get_shadow_caster_bounds_info__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_get_shadow_caster_bounds_info__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.get_shadow_caster_bounds_info", 
    "    Ogre::VisibleObjectsBoundsInfo const & SceneManager.get_shadow_caster_bounds_info(Ogre::Light const *light, size_t iteration)\n"
    "    Ogre::VisibleObjectsBoundsInfo const & SceneManager.get_shadow_caster_bounds_info(Ogre::Light const *light)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.set_camera_relative_rendering

  call-seq:
    set_camera_relative_rendering(bool rel)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_set_camera_relative_rendering(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);
  {
    try {
      (arg1)->setCameraRelativeRendering(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.get_camera_relative_rendering

  call-seq:
    get_camera_relative_rendering -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_get_camera_relative_rendering(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);
  {
    try {
      result = (bool)((Ogre::SceneManager const *)arg1)->getCameraRelativeRendering();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.add_lod_listener

  call-seq:
    add_lod_listener(LodListener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_add_lod_listener(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);
  {
    try {
      (arg1)->addLodListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.remove_lod_listener

  call-seq:
    remove_lod_listener(LodListener listener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_remove_lod_listener(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);
  {
    try {
      (arg1)->removeLodListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._notify_movable_object_lod_changed

  call-seq:
    _notify_movable_object_lod_changed(MovableObjectLodChangedEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__notify_movable_object_lod_changed(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);
  {
    try {
      (arg1)->_notifyMovableObjectLodChanged(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._notify_entity_mesh_lod_changed

  call-seq:
    _notify_entity_mesh_lod_changed(EntityMeshLodChangedEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__notify_entity_mesh_lod_changed(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);
  {
    try {
      (arg1)->_notifyEntityMeshLodChanged(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._notify_entity_material_lod_changed

  call-seq:
    _notify_entity_material_lod_changed(EntityMaterialLodChangedEvent evt)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__notify_entity_material_lod_changed(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);
  {
    try {
      (arg1)->_notifyEntityMaterialLodChanged(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager._handle_lod_events

  call-seq:
    _handle_lod_events

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager__handle_lod_events(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);
  {
    try {
      (arg1)->_handleLodEvents();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManager.create_movable_object

  call-seq:
    create_movable_object(String name, String typeName, NameValuePairList params=0) -> MovableObject
    create_movable_object(String name, String typeName) -> MovableObject
    create_movable_object(String typeName, NameValuePairList params=0) -> MovableObject
    create_movable_object(String typeName) -> MovableObject
    create_movable_object(String name, String typeName, VALUE params) -> MovableObject
    create_movable_object(String typeName, VALUE params) -> MovableObject

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManager_create_movable_object__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];
  {
    try {
      result = (Ogre::MovableObject *)Ogre_SceneManager_createMovableObject__SWIG_4(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_movable_object__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];
  {
    try {
      result = (Ogre::MovableObject *)Ogre_SceneManager_createMovableObject__SWIG_5(arg1,(std::string const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_movable_object(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_create_movable_object__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_create_movable_object__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_create_movable_object__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_create_movable_object__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_create_movable_object__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_create_movable_object__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneManager.create_movable_object", 
    "    Ogre::MovableObject * SceneManager.create_movable_object(Ogre::String const &name, Ogre::String const &typeName, Ogre::NameValuePairList const *params)\n"
    "    Ogre::MovableObject * SceneManager.create_movable_object(Ogre::String const &name, Ogre::String const &typeName)\n"
    "    Ogre::MovableObject * SceneManager.create_movable_object(Ogre::String const &typeName, Ogre::NameValuePairList const *params)\n"
    "    Ogre::MovableObject * SceneManager.create_movable_object(Ogre::String const &typeName)\n"
    "    Ogre::MovableObject * SceneManager.create_movable_object(Ogre::String const &name, Ogre::String const &typeName, VALUE params)\n"
    "    Ogre::MovableObject * SceneManager.create_movable_object(Ogre::String const &typeName, VALUE params)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::DefaultIntersectionSceneQuery < Ogre::Ogre::IntersectionSceneQuery

  Proxy of C++ Ogre::DefaultIntersectionSceneQuery class


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


/*
  Document-method: Ogre::DefaultIntersectionSceneQuery.new

  call-seq:
    DefaultIntersectionSceneQuery.new(SceneManager creator)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::DefaultIntersectionSceneQuery *)new Ogre::DefaultIntersectionSceneQuery(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultIntersectionSceneQuery(Ogre::DefaultIntersectionSceneQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DefaultIntersectionSceneQuery.execute

  call-seq:
    execute(IntersectionSceneQueryListener listener)

An instance method.

*/
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);
  {
    try {
      (arg1)->execute(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DefaultRaySceneQuery < Ogre::Ogre::RaySceneQuery

  Proxy of C++ Ogre::DefaultRaySceneQuery class


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


/*
  Document-method: Ogre::DefaultRaySceneQuery.new

  call-seq:
    DefaultRaySceneQuery.new(SceneManager creator)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::DefaultRaySceneQuery *)new Ogre::DefaultRaySceneQuery(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultRaySceneQuery(Ogre::DefaultRaySceneQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DefaultRaySceneQuery.execute

  call-seq:
    execute(RaySceneQueryListener listener)

An instance method.

*/
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);
  {
    try {
      (arg1)->execute(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DefaultSphereSceneQuery < Ogre::Ogre::SphereSceneQuery

  Proxy of C++ Ogre::DefaultSphereSceneQuery class


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


/*
  Document-method: Ogre::DefaultSphereSceneQuery.new

  call-seq:
    DefaultSphereSceneQuery.new(SceneManager creator)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::DefaultSphereSceneQuery *)new Ogre::DefaultSphereSceneQuery(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultSphereSceneQuery(Ogre::DefaultSphereSceneQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DefaultSphereSceneQuery.execute

  call-seq:
    execute(SceneQueryListener listener)

An instance method.

*/
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);
  {
    try {
      (arg1)->execute(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DefaultPlaneBoundedVolumeListSceneQuery < Ogre::Ogre::PlaneBoundedVolumeListSceneQuery

  Proxy of C++ Ogre::DefaultPlaneBoundedVolumeListSceneQuery class


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


/*
  Document-method: Ogre::DefaultPlaneBoundedVolumeListSceneQuery.new

  call-seq:
    DefaultPlaneBoundedVolumeListSceneQuery.new(SceneManager creator)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::DefaultPlaneBoundedVolumeListSceneQuery *)new Ogre::DefaultPlaneBoundedVolumeListSceneQuery(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultPlaneBoundedVolumeListSceneQuery(Ogre::DefaultPlaneBoundedVolumeListSceneQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DefaultPlaneBoundedVolumeListSceneQuery.execute

  call-seq:
    execute(SceneQueryListener listener)

An instance method.

*/
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);
  {
    try {
      (arg1)->execute(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DefaultAxisAlignedBoxSceneQuery < Ogre::Ogre::AxisAlignedBoxSceneQuery

  Proxy of C++ Ogre::DefaultAxisAlignedBoxSceneQuery class


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


/*
  Document-method: Ogre::DefaultAxisAlignedBoxSceneQuery.new

  call-seq:
    DefaultAxisAlignedBoxSceneQuery.new(SceneManager creator)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::DefaultAxisAlignedBoxSceneQuery *)new Ogre::DefaultAxisAlignedBoxSceneQuery(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultAxisAlignedBoxSceneQuery(Ogre::DefaultAxisAlignedBoxSceneQuery *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DefaultAxisAlignedBoxSceneQuery.execute

  call-seq:
    execute(SceneQueryListener listener)

An instance method.

*/
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);
  {
    try {
      (arg1)->execute(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::SceneManagerMetaData

  Proxy of C++ Ogre::SceneManagerMetaData class


*/
swig_class SwigClassSceneManagerMetaData;


/*
  Document-method: Ogre::SceneManagerMetaData.typeName

  call-seq:
    typeName -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneManagerMetaData.typeName=

  call-seq:
    typeName=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::SceneManagerMetaData.description

  call-seq:
    description -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneManagerMetaData.description=

  call-seq:
    description=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::SceneManagerMetaData.sceneTypeMask

  call-seq:
    sceneTypeMask -> SceneTypeMask

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneManagerMetaData.sceneTypeMask=

  call-seq:
    sceneTypeMask=(x) -> SceneTypeMask

Set new value for attribute.

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



/*
  Document-method: Ogre::SceneManagerMetaData.worldGeometrySupported

  call-seq:
    worldGeometrySupported -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::SceneManagerMetaData.worldGeometrySupported=

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

Set new value for attribute.

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


/*
  Document-method: Ogre::SceneManagerMetaData.new

  call-seq:
    SceneManagerMetaData.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SceneManagerMetaData *)new Ogre::SceneManagerMetaData();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SceneManagerMetaData(Ogre::SceneManagerMetaData *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::SceneManagerFactory

  Proxy of C++ Ogre::SceneManagerFactory class


*/
swig_class SwigClassSceneManagerFactory;

SWIGINTERN void
free_Ogre_SceneManagerFactory(Ogre::SceneManagerFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SceneManagerFactory.get_meta_data

  call-seq:
    get_meta_data -> SceneManagerMetaData

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerFactory_get_meta_data(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);
  {
    try {
      result = (Ogre::SceneManagerMetaData *) &((Ogre::SceneManagerFactory const *)arg1)->getMetaData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManagerMetaData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerFactory.create_instance

  call-seq:
    create_instance(String instanceName) -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerFactory_create_instance(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;
  }
  {
    try {
      result = (Ogre::SceneManager *)(arg1)->createInstance((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerFactory.destroy_instance

  call-seq:
    destroy_instance(SceneManager instance)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Root

  Proxy of C++ Ogre::Root class


*/
swig_class SwigClassRoot;


/*
  Document-method: Ogre::Root.new

  call-seq:
    Root.new(String pluginFileName="plugins.cfg", String configFileName="ogre.cfg", 
    String logFileName="Ogre.log")
    Root.new(String pluginFileName="plugins.cfg", String configFileName="ogre.cfg")
    Root.new(String pluginFileName="plugins.cfg")
    Root.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Root *)new Ogre::Root((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Root *)new Ogre::Root((Ogre::String const &)*arg1,(Ogre::String const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Root *)new Ogre::Root((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::Root *)new Ogre::Root();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}



/*
  Document-method: Ogre::Root.save_config

  call-seq:
    save_config

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_save_config(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);
  {
    try {
      (arg1)->saveConfig();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.restore_config

  call-seq:
    restore_config -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_restore_config(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);
  {
    try {
      result = (bool)(arg1)->restoreConfig();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.show_config_dialog

  call-seq:
    show_config_dialog -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_show_config_dialog(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);
  {
    try {
      result = (bool)(arg1)->showConfigDialog();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.add_render_system

  call-seq:
    add_render_system(RenderSystem newRend)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_add_render_system(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);
  {
    try {
      (arg1)->addRenderSystem(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_available_renderers

  call-seq:
    get_available_renderers -> RenderSystemList

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_available_renderers(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);
  {
    try {
      result = (Ogre::RenderSystemList *) &(arg1)->getAvailableRenderers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__RenderSystem_p_Ogre__STLAllocatorT_Ogre__RenderSystem_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_render_system_by_name

  call-seq:
    get_render_system_by_name(String name) -> RenderSystem

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_render_system_by_name(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;
  }
  {
    try {
      result = (Ogre::RenderSystem *)(arg1)->getRenderSystemByName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Root.set_render_system

  call-seq:
    set_render_system(RenderSystem system)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_set_render_system(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);
  {
    try {
      (arg1)->setRenderSystem(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_render_system

  call-seq:
    get_render_system -> RenderSystem

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_render_system(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);
  {
    try {
      result = (Ogre::RenderSystem *)(arg1)->getRenderSystem();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.initialise

  call-seq:
    initialise(bool autoCreateWindow, String windowTitle="OGRE Render Window", 
    String customCapabilitiesConfig=BLANK) -> RenderWindow
    initialise(bool autoCreateWindow, String windowTitle="OGRE Render Window") -> RenderWindow
    initialise(bool autoCreateWindow) -> RenderWindow

An instance method.

*/
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;
  }
  {
    try {
      result = (Ogre::RenderWindow *)(arg1)->initialise(arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
  }
  {
    try {
      result = (Ogre::RenderWindow *)(arg1)->initialise(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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);
  {
    try {
      result = (Ogre::RenderWindow *)(arg1)->initialise(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::Root.is_initialised

  call-seq:
    is_initialised -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_is_initialised(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);
  {
    try {
      result = (bool)((Ogre::Root const *)arg1)->isInitialised();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.use_custom_render_system_capabilities

  call-seq:
    use_custom_render_system_capabilities(RenderSystemCapabilities capabilities)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_use_custom_render_system_capabilities(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);
  {
    try {
      (arg1)->useCustomRenderSystemCapabilities(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_remove_render_queue_structures_on_clear

  call-seq:
    get_remove_render_queue_structures_on_clear -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_remove_render_queue_structures_on_clear(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);
  {
    try {
      result = (bool)((Ogre::Root const *)arg1)->getRemoveRenderQueueStructuresOnClear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.set_remove_render_queue_structures_on_clear

  call-seq:
    set_remove_render_queue_structures_on_clear(bool r)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_set_remove_render_queue_structures_on_clear(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);
  {
    try {
      (arg1)->setRemoveRenderQueueStructuresOnClear(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.add_scene_manager_factory

  call-seq:
    add_scene_manager_factory(SceneManagerFactory fact)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_add_scene_manager_factory(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);
  {
    try {
      (arg1)->addSceneManagerFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.remove_scene_manager_factory

  call-seq:
    remove_scene_manager_factory(SceneManagerFactory fact)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_remove_scene_manager_factory(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);
  {
    try {
      (arg1)->removeSceneManagerFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_scene_manager_meta_data

  call-seq:
    get_scene_manager_meta_data(String typeName) -> SceneManagerMetaData

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_scene_manager_meta_data(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;
  }
  {
    try {
      result = (Ogre::SceneManagerMetaData *)((Ogre::Root const *)arg1)->getSceneManagerMetaData((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManagerMetaData, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_scene_manager_meta_data_iterator

  call-seq:
    get_scene_manager_meta_data_iterator -> MetaDataIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_scene_manager_meta_data_iterator(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);
  {
    try {
      result = ((Ogre::Root const *)arg1)->getSceneManagerMetaDataIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::SceneManagerEnumerator::MetaDataIterator(static_cast< const Ogre::SceneManagerEnumerator::MetaDataIterator& >(result))), SWIGTYPE_p_Ogre__SceneManagerEnumerator__MetaDataIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.create_scene_manager

  call-seq:
    create_scene_manager(String typeName, String instanceName=BLANK) -> SceneManager
    create_scene_manager(String typeName) -> SceneManager
    create_scene_manager(SceneTypeMask typeMask, String instanceName=BLANK) -> SceneManager
    create_scene_manager(SceneTypeMask typeMask) -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_create_scene_manager__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;
  }
  {
    try {
      result = (Ogre::SceneManager *)(arg1)->createSceneManager((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_create_scene_manager__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;
  }
  {
    try {
      result = (Ogre::SceneManager *)(arg1)->createSceneManager((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_scene_manager__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;
  }
  {
    try {
      result = (Ogre::SceneManager *)(arg1)->createSceneManager(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_create_scene_manager__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);
  {
    try {
      result = (Ogre::SceneManager *)(arg1)->createSceneManager(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_create_scene_manager(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_create_scene_manager__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_create_scene_manager__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_create_scene_manager__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_create_scene_manager__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Root.create_scene_manager", 
    "    Ogre::SceneManager * Root.create_scene_manager(Ogre::String const &typeName, Ogre::String const &instanceName)\n"
    "    Ogre::SceneManager * Root.create_scene_manager(Ogre::String const &typeName)\n"
    "    Ogre::SceneManager * Root.create_scene_manager(Ogre::SceneTypeMask typeMask, Ogre::String const &instanceName)\n"
    "    Ogre::SceneManager * Root.create_scene_manager(Ogre::SceneTypeMask typeMask)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root.destroy_scene_manager

  call-seq:
    destroy_scene_manager(SceneManager sm)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_destroy_scene_manager(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);
  {
    try {
      (arg1)->destroySceneManager(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_scene_manager

  call-seq:
    get_scene_manager(String instanceName) -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_scene_manager(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;
  }
  {
    try {
      result = (Ogre::SceneManager *)((Ogre::Root const *)arg1)->getSceneManager((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Root.has_scene_manager

  call-seq:
    has_scene_manager(String instanceName) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_has_scene_manager(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;
  }
  {
    try {
      result = (bool)((Ogre::Root const *)arg1)->hasSceneManager((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_scene_manager_iterator

  call-seq:
    get_scene_manager_iterator -> SceneManagerIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_scene_manager_iterator(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);
  {
    try {
      result = (arg1)->getSceneManagerIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::SceneManagerEnumerator::SceneManagerIterator(static_cast< const Ogre::SceneManagerEnumerator::SceneManagerIterator& >(result))), SWIGTYPE_p_Ogre__SceneManagerEnumerator__SceneManagerIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_texture_manager

  call-seq:
    get_texture_manager -> TextureManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_texture_manager(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);
  {
    try {
      result = (Ogre::TextureManager *)(arg1)->getTextureManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_mesh_manager

  call-seq:
    get_mesh_manager -> MeshManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_mesh_manager(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);
  {
    try {
      result = (Ogre::MeshManager *)(arg1)->getMeshManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_error_description

  call-seq:
    get_error_description(long errorNumber) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_error_description(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);
  {
    try {
      result = (arg1)->getErrorDescription(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.add_frame_listener

  call-seq:
    add_frame_listener(FrameListener newListener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_add_frame_listener(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);
  {
    try {
      (arg1)->addFrameListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.remove_frame_listener

  call-seq:
    remove_frame_listener(FrameListener oldListener)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_remove_frame_listener(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);
  {
    try {
      (arg1)->removeFrameListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.queue_end_rendering

  call-seq:
    queue_end_rendering

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_queue_end_rendering(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);
  {
    try {
      (arg1)->queueEndRendering();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.start_rendering

  call-seq:
    start_rendering

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_start_rendering(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);
  {
    try {
      (arg1)->startRendering();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.render_one_frame

  call-seq:
    render_one_frame -> bool
    render_one_frame(Real timeSinceLastFrame) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_render_one_frame__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);
  {
    try {
      result = (bool)(arg1)->renderOneFrame();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_render_one_frame__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);
  {
    try {
      result = (bool)(arg1)->renderOneFrame(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_render_one_frame(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_render_one_frame__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_render_one_frame__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root.render_one_frame", 
    "    bool Root.render_one_frame()\n"
    "    bool Root.render_one_frame(Ogre::Real timeSinceLastFrame)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root.shutdown

  call-seq:
    shutdown

An instance method.

*/
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);
  {
    try {
      (arg1)->shutdown();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.add_resource_location

  call-seq:
    add_resource_location(String name, String locType, String groupName=DEFAULT_RESOURCE_GROUP_NAME, 
    bool recursive=false)
    add_resource_location(String name, String locType, String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    add_resource_location(String name, String locType)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_add_resource_location__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);
  {
    try {
      (arg1)->addResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_add_resource_location__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;
  }
  {
    try {
      (arg1)->addResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  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_add_resource_location__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;
  }
  {
    try {
      (arg1)->addResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_add_resource_location(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_add_resource_location__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_add_resource_location__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_add_resource_location__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Root.add_resource_location", 
    "    void Root.add_resource_location(Ogre::String const &name, Ogre::String const &locType, Ogre::String const &groupName, bool recursive)\n"
    "    void Root.add_resource_location(Ogre::String const &name, Ogre::String const &locType, Ogre::String const &groupName)\n"
    "    void Root.add_resource_location(Ogre::String const &name, Ogre::String const &locType)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root.remove_resource_location

  call-seq:
    remove_resource_location(String name, String groupName=DEFAULT_RESOURCE_GROUP_NAME)
    remove_resource_location(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_remove_resource_location__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;
  }
  {
    try {
      (arg1)->removeResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_remove_resource_location__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;
  }
  {
    try {
      (arg1)->removeResourceLocation((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_remove_resource_location(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_remove_resource_location__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_remove_resource_location__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Root.remove_resource_location", 
    "    void Root.remove_resource_location(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    void Root.remove_resource_location(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root.create_file_stream

  call-seq:
    create_file_stream(String filename, String groupName=DEFAULT_RESOURCE_GROUP_NAME, 
    bool overwrite=false, String locationPattern=BLANK) -> DataStreamPtr
    create_file_stream(String filename, String groupName=DEFAULT_RESOURCE_GROUP_NAME, 
    bool overwrite=false) -> DataStreamPtr
    create_file_stream(String filename, String groupName=DEFAULT_RESOURCE_GROUP_NAME) -> DataStreamPtr
    create_file_stream(String filename) -> DataStreamPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_create_file_stream__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;
  }
  {
    try {
      result = (arg1)->createFileStream((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_create_file_stream__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);
  {
    try {
      result = (arg1)->createFileStream((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_create_file_stream__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;
  }
  {
    try {
      result = (arg1)->createFileStream((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_file_stream__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;
  }
  {
    try {
      result = (arg1)->createFileStream((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_create_file_stream(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_create_file_stream__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_create_file_stream__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_create_file_stream__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_create_file_stream__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Root.create_file_stream", 
    "    Ogre::DataStreamPtr Root.create_file_stream(Ogre::String const &filename, Ogre::String const &groupName, bool overwrite, Ogre::String const &locationPattern)\n"
    "    Ogre::DataStreamPtr Root.create_file_stream(Ogre::String const &filename, Ogre::String const &groupName, bool overwrite)\n"
    "    Ogre::DataStreamPtr Root.create_file_stream(Ogre::String const &filename, Ogre::String const &groupName)\n"
    "    Ogre::DataStreamPtr Root.create_file_stream(Ogre::String const &filename)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root.open_file_stream

  call-seq:
    open_file_stream(String filename, String groupName=DEFAULT_RESOURCE_GROUP_NAME, 
    String locationPattern=BLANK) -> DataStreamPtr
    open_file_stream(String filename, String groupName=DEFAULT_RESOURCE_GROUP_NAME) -> DataStreamPtr
    open_file_stream(String filename) -> DataStreamPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_open_file_stream__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;
  }
  {
    try {
      result = (arg1)->openFileStream((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_open_file_stream__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;
  }
  {
    try {
      result = (arg1)->openFileStream((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_open_file_stream__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;
  }
  {
    try {
      result = (arg1)->openFileStream((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_open_file_stream(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_open_file_stream__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_open_file_stream__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_open_file_stream__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Root.open_file_stream", 
    "    Ogre::DataStreamPtr Root.open_file_stream(Ogre::String const &filename, Ogre::String const &groupName, Ogre::String const &locationPattern)\n"
    "    Ogre::DataStreamPtr Root.open_file_stream(Ogre::String const &filename, Ogre::String const &groupName)\n"
    "    Ogre::DataStreamPtr Root.open_file_stream(Ogre::String const &filename)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root.convert_colour_value

  call-seq:
    convert_colour_value(ColourValue colour, uint32 pDest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_convert_colour_value(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);
  {
    try {
      (arg1)->convertColourValue((Ogre::ColourValue const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_auto_created_window

  call-seq:
    get_auto_created_window -> RenderWindow

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_auto_created_window(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);
  {
    try {
      result = (Ogre::RenderWindow *)(arg1)->getAutoCreatedWindow();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.create_render_window

  call-seq:
    create_render_window(String name, unsigned int width, unsigned int height, 
    bool fullScreen, NameValuePairList miscParams=0) -> RenderWindow
    create_render_window(String name, unsigned int width, unsigned int height, 
    bool fullScreen) -> RenderWindow

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_create_render_window__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);
  {
    try {
      result = (Ogre::RenderWindow *)(arg1)->createRenderWindow((Ogre::String const &)*arg2,arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_create_render_window__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);
  {
    try {
      result = (Ogre::RenderWindow *)(arg1)->createRenderWindow((Ogre::String const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_render_window(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_create_render_window__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_create_render_window__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Root.create_render_window", 
    "    Ogre::RenderWindow * Root.create_render_window(Ogre::String const &name, unsigned int width, unsigned int height, bool fullScreen, Ogre::NameValuePairList const *miscParams)\n"
    "    Ogre::RenderWindow * Root.create_render_window(Ogre::String const &name, unsigned int width, unsigned int height, bool fullScreen)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root.create_render_windows

  call-seq:
    create_render_windows(RenderWindowDescriptionList renderWindowDescriptions, 
    RenderWindowList createdWindows) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_create_render_windows(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);
  {
    try {
      result = (bool)(arg1)->createRenderWindows((Ogre::RenderWindowDescriptionList const &)*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.detach_render_target

  call-seq:
    detach_render_target(RenderTarget pWin) -> RenderTarget
    detach_render_target(String name) -> RenderTarget

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_detach_render_target__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);
  {
    try {
      result = (Ogre::RenderTarget *)(arg1)->detachRenderTarget(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_detach_render_target__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;
  }
  {
    try {
      result = (Ogre::RenderTarget *)(arg1)->detachRenderTarget((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_detach_render_target(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_detach_render_target__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_detach_render_target__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root.detach_render_target", 
    "    Ogre::RenderTarget * Root.detach_render_target(Ogre::RenderTarget *pWin)\n"
    "    Ogre::RenderTarget * Root.detach_render_target(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root.destroy_render_target

  call-seq:
    destroy_render_target(RenderTarget target)
    destroy_render_target(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_destroy_render_target__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);
  {
    try {
      (arg1)->destroyRenderTarget(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_destroy_render_target__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;
  }
  {
    try {
      (arg1)->destroyRenderTarget((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_destroy_render_target(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_destroy_render_target__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_destroy_render_target__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root.destroy_render_target", 
    "    void Root.destroy_render_target(Ogre::RenderTarget *target)\n"
    "    void Root.destroy_render_target(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_render_target

  call-seq:
    get_render_target(String name) -> RenderTarget

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_render_target(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;
  }
  {
    try {
      result = (Ogre::RenderTarget *)(arg1)->getRenderTarget((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Root.load_plugin

  call-seq:
    load_plugin(String pluginName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_load_plugin(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;
  }
  {
    try {
      (arg1)->loadPlugin((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Root.unload_plugin

  call-seq:
    unload_plugin(String pluginName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_unload_plugin(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;
  }
  {
    try {
      (arg1)->unloadPlugin((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Root.install_plugin

  call-seq:
    install_plugin(Plugin plugin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_install_plugin(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);
  {
    try {
      (arg1)->installPlugin(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.uninstall_plugin

  call-seq:
    uninstall_plugin(Plugin plugin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_uninstall_plugin(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);
  {
    try {
      (arg1)->uninstallPlugin(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_installed_plugins

  call-seq:
    get_installed_plugins -> PluginInstanceList

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_installed_plugins(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);
  {
    try {
      result = (Ogre::Root::PluginInstanceList *) &((Ogre::Root const *)arg1)->getInstalledPlugins();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Plugin_p_Ogre__STLAllocatorT_Ogre__Plugin_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_timer

  call-seq:
    get_timer -> Timer

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_timer(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);
  {
    try {
      result = (Ogre::Timer *)(arg1)->getTimer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Timer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root._fire_frame_started

  call-seq:
    _fire_frame_started(FrameEvent evt) -> bool
    _fire_frame_started -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root__fire_frame_started__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);
  {
    try {
      result = (bool)(arg1)->_fireFrameStarted(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root._fire_frame_rendering_queued

  call-seq:
    _fire_frame_rendering_queued(FrameEvent evt) -> bool
    _fire_frame_rendering_queued -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root__fire_frame_rendering_queued__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);
  {
    try {
      result = (bool)(arg1)->_fireFrameRenderingQueued(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root._fire_frame_ended

  call-seq:
    _fire_frame_ended(FrameEvent evt) -> bool
    _fire_frame_ended -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root__fire_frame_ended__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);
  {
    try {
      result = (bool)(arg1)->_fireFrameEnded(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root._fire_frame_started

  call-seq:
    _fire_frame_started(FrameEvent evt) -> bool
    _fire_frame_started -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root__fire_frame_started__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);
  {
    try {
      result = (bool)(arg1)->_fireFrameStarted();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root__fire_frame_started(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__fire_frame_started__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__fire_frame_started__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root._fire_frame_started", 
    "    bool Root._fire_frame_started(Ogre::FrameEvent &evt)\n"
    "    bool Root._fire_frame_started()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root._fire_frame_rendering_queued

  call-seq:
    _fire_frame_rendering_queued(FrameEvent evt) -> bool
    _fire_frame_rendering_queued -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root__fire_frame_rendering_queued__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);
  {
    try {
      result = (bool)(arg1)->_fireFrameRenderingQueued();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root__fire_frame_rendering_queued(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__fire_frame_rendering_queued__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__fire_frame_rendering_queued__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root._fire_frame_rendering_queued", 
    "    bool Root._fire_frame_rendering_queued(Ogre::FrameEvent &evt)\n"
    "    bool Root._fire_frame_rendering_queued()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root._fire_frame_ended

  call-seq:
    _fire_frame_ended(FrameEvent evt) -> bool
    _fire_frame_ended -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root__fire_frame_ended__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);
  {
    try {
      result = (bool)(arg1)->_fireFrameEnded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root__fire_frame_ended(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__fire_frame_ended__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__fire_frame_ended__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root._fire_frame_ended", 
    "    bool Root._fire_frame_ended(Ogre::FrameEvent &evt)\n"
    "    bool Root._fire_frame_ended()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_next_frame_number

  call-seq:
    get_next_frame_number -> unsigned long

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_next_frame_number(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);
  {
    try {
      result = (unsigned long)((Ogre::Root const *)arg1)->getNextFrameNumber();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root._get_current_scene_manager

  call-seq:
    _get_current_scene_manager -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root__get_current_scene_manager(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);
  {
    try {
      result = (Ogre::SceneManager *)((Ogre::Root const *)arg1)->_getCurrentSceneManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root._push_current_scene_manager

  call-seq:
    _push_current_scene_manager(SceneManager sm)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root__push_current_scene_manager(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);
  {
    try {
      (arg1)->_pushCurrentSceneManager(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root._pop_current_scene_manager

  call-seq:
    _pop_current_scene_manager(SceneManager sm)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root__pop_current_scene_manager(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);
  {
    try {
      (arg1)->_popCurrentSceneManager(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root._update_all_render_targets

  call-seq:
    _update_all_render_targets -> bool
    _update_all_render_targets(FrameEvent evt) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root__update_all_render_targets__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);
  {
    try {
      result = (bool)(arg1)->_updateAllRenderTargets();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__update_all_render_targets__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);
  {
    try {
      result = (bool)(arg1)->_updateAllRenderTargets(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root__update_all_render_targets(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__update_all_render_targets__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__update_all_render_targets__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root._update_all_render_targets", 
    "    bool Root._update_all_render_targets()\n"
    "    bool Root._update_all_render_targets(Ogre::FrameEvent &evt)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root.create_render_queue_invocation_sequence

  call-seq:
    create_render_queue_invocation_sequence(String name) -> RenderQueueInvocationSequence

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_create_render_queue_invocation_sequence(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;
  }
  {
    try {
      result = (Ogre::RenderQueueInvocationSequence *)(arg1)->createRenderQueueInvocationSequence((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_render_queue_invocation_sequence

  call-seq:
    get_render_queue_invocation_sequence(String name) -> RenderQueueInvocationSequence

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_render_queue_invocation_sequence(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;
  }
  {
    try {
      result = (Ogre::RenderQueueInvocationSequence *)(arg1)->getRenderQueueInvocationSequence((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Root.destroy_render_queue_invocation_sequence

  call-seq:
    destroy_render_queue_invocation_sequence(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_destroy_render_queue_invocation_sequence(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;
  }
  {
    try {
      (arg1)->destroyRenderQueueInvocationSequence((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Root.destroy_all_render_queue_invocation_sequences

  call-seq:
    destroy_all_render_queue_invocation_sequences

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_destroy_all_render_queue_invocation_sequences(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);
  {
    try {
      (arg1)->destroyAllRenderQueueInvocationSequences();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_singleton

  call-seq:
    get_singleton -> Root

A class method.

*/
SWIGINTERN VALUE
_wrap_Root_get_singleton(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;
  }
  {
    try {
      result = (Ogre::Root *) &Ogre::Root::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Root, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> Root

A class method.

*/
SWIGINTERN VALUE
_wrap_Root_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::Root *)Ogre::Root::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Root, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.clear_event_times

  call-seq:
    clear_event_times

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_clear_event_times(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);
  {
    try {
      (arg1)->clearEventTimes();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.set_frame_smoothing_period

  call-seq:
    set_frame_smoothing_period(Real period)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_set_frame_smoothing_period(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);
  {
    try {
      (arg1)->setFrameSmoothingPeriod(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_frame_smoothing_period

  call-seq:
    get_frame_smoothing_period -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_frame_smoothing_period(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Root const *)arg1)->getFrameSmoothingPeriod();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.add_movable_object_factory

  call-seq:
    add_movable_object_factory(MovableObjectFactory fact, bool overrideExisting=false)
    add_movable_object_factory(MovableObjectFactory fact)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_add_movable_object_factory__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);
  {
    try {
      (arg1)->addMovableObjectFactory(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_add_movable_object_factory__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);
  {
    try {
      (arg1)->addMovableObjectFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_add_movable_object_factory(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_add_movable_object_factory__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_add_movable_object_factory__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Root.add_movable_object_factory", 
    "    void Root.add_movable_object_factory(Ogre::MovableObjectFactory *fact, bool overrideExisting)\n"
    "    void Root.add_movable_object_factory(Ogre::MovableObjectFactory *fact)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Root.remove_movable_object_factory

  call-seq:
    remove_movable_object_factory(MovableObjectFactory fact)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_remove_movable_object_factory(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);
  {
    try {
      (arg1)->removeMovableObjectFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.has_movable_object_factory

  call-seq:
    has_movable_object_factory(String typeName) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_has_movable_object_factory(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;
  }
  {
    try {
      result = (bool)((Ogre::Root const *)arg1)->hasMovableObjectFactory((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_movable_object_factory

  call-seq:
    get_movable_object_factory(String typeName) -> MovableObjectFactory

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_movable_object_factory(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;
  }
  {
    try {
      result = (Ogre::MovableObjectFactory *)(arg1)->getMovableObjectFactory((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObjectFactory, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Root._allocate_next_movable_object_type_flag

  call-seq:
    _allocate_next_movable_object_type_flag -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root__allocate_next_movable_object_type_flag(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);
  {
    try {
      result = (Ogre::uint32)(arg1)->_allocateNextMovableObjectTypeFlag();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_movable_object_factory_iterator

  call-seq:
    get_movable_object_factory_iterator -> MovableObjectFactoryIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_movable_object_factory_iterator(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);
  {
    try {
      result = ((Ogre::Root const *)arg1)->getMovableObjectFactoryIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Root::MovableObjectFactoryIterator(static_cast< const Ogre::Root::MovableObjectFactoryIterator& >(result))), SWIGTYPE_p_Ogre__Root__MovableObjectFactoryIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_display_monitor_count

  call-seq:
    get_display_monitor_count -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_display_monitor_count(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);
  {
    try {
      result = (unsigned int)((Ogre::Root const *)arg1)->getDisplayMonitorCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_work_queue

  call-seq:
    get_work_queue -> WorkQueue

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_work_queue(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);
  {
    try {
      result = (Ogre::WorkQueue *)((Ogre::Root const *)arg1)->getWorkQueue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.set_work_queue

  call-seq:
    set_work_queue(WorkQueue queue)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_set_work_queue(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);
  {
    try {
      (arg1)->setWorkQueue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.set_blend_indices_gpu_redundant

  call-seq:
    set_blend_indices_gpu_redundant(bool redundant)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_set_blend_indices_gpu_redundant(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);
  {
    try {
      (arg1)->setBlendIndicesGpuRedundant(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.is_blend_indices_gpu_redundant

  call-seq:
    is_blend_indices_gpu_redundant -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_is_blend_indices_gpu_redundant(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);
  {
    try {
      result = (bool)((Ogre::Root const *)arg1)->isBlendIndicesGpuRedundant();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.set_blend_weights_gpu_redundant

  call-seq:
    set_blend_weights_gpu_redundant(bool redundant)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_set_blend_weights_gpu_redundant(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);
  {
    try {
      (arg1)->setBlendWeightsGpuRedundant(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.is_blend_weights_gpu_redundant

  call-seq:
    is_blend_weights_gpu_redundant -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_is_blend_weights_gpu_redundant(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);
  {
    try {
      result = (bool)((Ogre::Root const *)arg1)->isBlendWeightsGpuRedundant();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.set_default_min_pixel_size

  call-seq:
    set_default_min_pixel_size(Real pixelSize)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_set_default_min_pixel_size(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);
  {
    try {
      (arg1)->setDefaultMinPixelSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_default_min_pixel_size

  call-seq:
    get_default_min_pixel_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_default_min_pixel_size(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getDefaultMinPixelSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.get_available_renderer_array

  call-seq:
    get_available_renderer_array(void ?) -> VALUE

An instance method.

*/
SWIGINTERN VALUE
_wrap_Root_get_available_renderer_array(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);
  {
    try {
      result = (VALUE)Ogre_Root_getAvailableRendererArray(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = result;
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Root.destruct

  call-seq:
    destruct

An instance method.

*/
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);
  {
    try {
      Ogre_Root_destruct(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DefaultSceneManagerFactory < Ogre::Ogre::SceneManagerFactory

  Proxy of C++ Ogre::DefaultSceneManagerFactory class


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


/*
  Document-method: Ogre::DefaultSceneManagerFactory.new

  call-seq:
    DefaultSceneManagerFactory.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::DefaultSceneManagerFactory *)new Ogre::DefaultSceneManagerFactory();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultSceneManagerFactory(Ogre::DefaultSceneManagerFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::DefaultSceneManagerFactory.FACTORY_TYPE_NAME

  call-seq:
    FACTORY_TYPE_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::DefaultSceneManagerFactory.DefaultSceneManagerFactory_FACTORY_TYPE_NAME

  call-seq:
    DefaultSceneManagerFactory_FACTORY_TYPE_NAME -> String

Get value of attribute.

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



/*
  Document-method: Ogre::DefaultSceneManagerFactory.create_instance

  call-seq:
    create_instance(String instanceName) -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultSceneManagerFactory_create_instance(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;
  }
  {
    try {
      result = (Ogre::SceneManager *)(arg1)->createInstance((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::DefaultSceneManagerFactory.destroy_instance

  call-seq:
    destroy_instance(SceneManager instance)

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultSceneManagerFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::DefaultSceneManager < Ogre::Ogre::SceneManager

  Proxy of C++ Ogre::DefaultSceneManager class


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


/*
  Document-method: Ogre::DefaultSceneManager.new

  call-seq:
    DefaultSceneManager.new(String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::DefaultSceneManager *)new Ogre::DefaultSceneManager((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::DefaultSceneManager.get_type_name

  call-seq:
    get_type_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_DefaultSceneManager_get_type_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::DefaultSceneManager const *)arg1)->getTypeName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::SceneManagerEnumerator

  Proxy of C++ Ogre::SceneManagerEnumerator class


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


/*
  Document-method: Ogre::SceneManagerEnumerator.new

  call-seq:
    SceneManagerEnumerator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SceneManagerEnumerator *)new Ogre::SceneManagerEnumerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SceneManagerEnumerator(Ogre::SceneManagerEnumerator *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SceneManagerEnumerator.add_factory

  call-seq:
    add_factory(SceneManagerFactory fact)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_add_factory(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);
  {
    try {
      (arg1)->addFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerEnumerator.remove_factory

  call-seq:
    remove_factory(SceneManagerFactory fact)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_remove_factory(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);
  {
    try {
      (arg1)->removeFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerEnumerator.get_meta_data

  call-seq:
    get_meta_data(String typeName) -> SceneManagerMetaData

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_get_meta_data(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;
  }
  {
    try {
      result = (Ogre::SceneManagerMetaData *)((Ogre::SceneManagerEnumerator const *)arg1)->getMetaData((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManagerMetaData, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerEnumerator.get_meta_data_iterator

  call-seq:
    get_meta_data_iterator -> MetaDataIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_get_meta_data_iterator(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);
  {
    try {
      result = ((Ogre::SceneManagerEnumerator const *)arg1)->getMetaDataIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::SceneManagerEnumerator::MetaDataIterator(static_cast< const Ogre::SceneManagerEnumerator::MetaDataIterator& >(result))), SWIGTYPE_p_Ogre__SceneManagerEnumerator__MetaDataIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerEnumerator.create_scene_manager

  call-seq:
    create_scene_manager(String typeName, String instanceName=BLANK) -> SceneManager
    create_scene_manager(String typeName) -> SceneManager
    create_scene_manager(SceneTypeMask typeMask, String instanceName=BLANK) -> SceneManager
    create_scene_manager(SceneTypeMask typeMask) -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_create_scene_manager__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;
  }
  {
    try {
      result = (Ogre::SceneManager *)(arg1)->createSceneManager((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_create_scene_manager__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;
  }
  {
    try {
      result = (Ogre::SceneManager *)(arg1)->createSceneManager((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_scene_manager__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;
  }
  {
    try {
      result = (Ogre::SceneManager *)(arg1)->createSceneManager(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_create_scene_manager__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);
  {
    try {
      result = (Ogre::SceneManager *)(arg1)->createSceneManager(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManagerEnumerator_create_scene_manager(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_create_scene_manager__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_create_scene_manager__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_create_scene_manager__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_create_scene_manager__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManagerEnumerator.create_scene_manager", 
    "    Ogre::SceneManager * SceneManagerEnumerator.create_scene_manager(Ogre::String const &typeName, Ogre::String const &instanceName)\n"
    "    Ogre::SceneManager * SceneManagerEnumerator.create_scene_manager(Ogre::String const &typeName)\n"
    "    Ogre::SceneManager * SceneManagerEnumerator.create_scene_manager(Ogre::SceneTypeMask typeMask, Ogre::String const &instanceName)\n"
    "    Ogre::SceneManager * SceneManagerEnumerator.create_scene_manager(Ogre::SceneTypeMask typeMask)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerEnumerator.destroy_scene_manager

  call-seq:
    destroy_scene_manager(SceneManager sm)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_destroy_scene_manager(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);
  {
    try {
      (arg1)->destroySceneManager(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerEnumerator.get_scene_manager

  call-seq:
    get_scene_manager(String instanceName) -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_get_scene_manager(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;
  }
  {
    try {
      result = (Ogre::SceneManager *)((Ogre::SceneManagerEnumerator const *)arg1)->getSceneManager((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerEnumerator.has_scene_manager

  call-seq:
    has_scene_manager(String instanceName) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_has_scene_manager(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;
  }
  {
    try {
      result = (bool)((Ogre::SceneManagerEnumerator const *)arg1)->hasSceneManager((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerEnumerator.get_scene_manager_iterator

  call-seq:
    get_scene_manager_iterator -> SceneManagerIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_get_scene_manager_iterator(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);
  {
    try {
      result = (arg1)->getSceneManagerIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::SceneManagerEnumerator::SceneManagerIterator(static_cast< const Ogre::SceneManagerEnumerator::SceneManagerIterator& >(result))), SWIGTYPE_p_Ogre__SceneManagerEnumerator__SceneManagerIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerEnumerator.set_render_system

  call-seq:
    set_render_system(RenderSystem rs)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_set_render_system(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);
  {
    try {
      (arg1)->setRenderSystem(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerEnumerator.shutdown_all

  call-seq:
    shutdown_all

An instance method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_shutdown_all(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);
  {
    try {
      (arg1)->shutdownAll();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerEnumerator.get_singleton

  call-seq:
    get_singleton -> SceneManagerEnumerator

A class method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_get_singleton(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;
  }
  {
    try {
      result = (Ogre::SceneManagerEnumerator *) &Ogre::SceneManagerEnumerator::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManagerEnumerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SceneManagerEnumerator.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> SceneManagerEnumerator

A class method.

*/
SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::SceneManagerEnumerator *)Ogre::SceneManagerEnumerator::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManagerEnumerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ScriptToken

  Proxy of C++ Ogre::ScriptToken class


*/
swig_class SwigClassScriptToken;


/*
  Document-method: Ogre::ScriptToken.lexeme

  call-seq:
    lexeme -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ScriptToken.lexeme=

  call-seq:
    lexeme=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ScriptToken.file

  call-seq:
    file -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ScriptToken.file=

  call-seq:
    file=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ScriptToken.type

  call-seq:
    type -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::ScriptToken.type=

  call-seq:
    type=(x) -> uint32

Set new value for attribute.

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



/*
  Document-method: Ogre::ScriptToken.line

  call-seq:
    line -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::ScriptToken.line=

  call-seq:
    line=(x) -> uint32

Set new value for attribute.

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


/*
  Document-method: Ogre::ScriptToken.new

  call-seq:
    ScriptToken.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ScriptToken *)new Ogre::ScriptToken();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptToken(Ogre::ScriptToken *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ScriptLexer

  Proxy of C++ Ogre::ScriptLexer class


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


/*
  Document-method: Ogre::ScriptLexer.new

  call-seq:
    ScriptLexer.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ScriptLexer *)new Ogre::ScriptLexer();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptLexer(Ogre::ScriptLexer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ScriptLexer.tokenize

  call-seq:
    tokenize(String str, String source) -> ScriptTokenListPtr

An instance method.

*/
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;
  }
  {
    try {
      result = (arg1)->tokenize((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-class: Ogre::ScriptParser

  Proxy of C++ Ogre::ScriptParser class


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


/*
  Document-method: Ogre::ScriptParser.new

  call-seq:
    ScriptParser.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ScriptParser *)new Ogre::ScriptParser();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptParser(Ogre::ScriptParser *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ScriptParser.parse

  call-seq:
    parse(ScriptTokenListPtr tokens) -> ConcreteNodeListPtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->parse((Ogre::ScriptTokenListPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ScriptParser.parse_chunk

  call-seq:
    parse_chunk(ScriptTokenListPtr tokens) -> ConcreteNodeListPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptParser_parse_chunk(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);
  {
    try {
      result = (arg1)->parseChunk((Ogre::ScriptTokenListPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-class: Ogre::ScriptTranslator

  Proxy of C++ Ogre::ScriptTranslator class


*/
swig_class SwigClassScriptTranslator;


/*
  Document-method: Ogre::ScriptTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ScriptTranslatorManager

  Proxy of C++ Ogre::ScriptTranslatorManager class


*/
swig_class SwigClassScriptTranslatorManager;

SWIGINTERN void
free_Ogre_ScriptTranslatorManager(Ogre::ScriptTranslatorManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ScriptTranslatorManager.get_num_translators

  call-seq:
    get_num_translators -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptTranslatorManager_get_num_translators(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);
  {
    try {
      result = ((Ogre::ScriptTranslatorManager const *)arg1)->getNumTranslators();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ScriptTranslatorManager.get_translator

  call-seq:
    get_translator(AbstractNodePtr ?) -> ScriptTranslator

An instance method.

*/
SWIGINTERN VALUE
_wrap_ScriptTranslatorManager_get_translator(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);
  {
    try {
      result = (Ogre::ScriptTranslator *)(arg1)->getTranslator((Ogre::AbstractNodePtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptTranslator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::MaterialTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::MaterialTranslator class


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


/*
  Document-method: Ogre::MaterialTranslator.new

  call-seq:
    MaterialTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::MaterialTranslator *)new Ogre::MaterialTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::MaterialTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MaterialTranslator(Ogre::MaterialTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::TechniqueTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::TechniqueTranslator class


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


/*
  Document-method: Ogre::TechniqueTranslator.new

  call-seq:
    TechniqueTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TechniqueTranslator *)new Ogre::TechniqueTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TechniqueTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TechniqueTranslator(Ogre::TechniqueTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::PassTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::PassTranslator class


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


/*
  Document-method: Ogre::PassTranslator.new

  call-seq:
    PassTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PassTranslator *)new Ogre::PassTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PassTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PassTranslator(Ogre::PassTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::TextureUnitTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::TextureUnitTranslator class


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


/*
  Document-method: Ogre::TextureUnitTranslator.new

  call-seq:
    TextureUnitTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TextureUnitTranslator *)new Ogre::TextureUnitTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureUnitTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TextureUnitTranslator(Ogre::TextureUnitTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::TextureSourceTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::TextureSourceTranslator class


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


/*
  Document-method: Ogre::TextureSourceTranslator.new

  call-seq:
    TextureSourceTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TextureSourceTranslator *)new Ogre::TextureSourceTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TextureSourceTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TextureSourceTranslator(Ogre::TextureSourceTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::GpuProgramTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::GpuProgramTranslator class


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


/*
  Document-method: Ogre::GpuProgramTranslator.new

  call-seq:
    GpuProgramTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::GpuProgramTranslator *)new Ogre::GpuProgramTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GpuProgramTranslator.translate_program_parameters

  call-seq:
    translate_program_parameters(ScriptCompiler compiler, GpuProgramParametersSharedPtr params, 
    ObjectAbstractNode obj)

A class method.

*/
SWIGINTERN VALUE
_wrap_GpuProgramTranslator_translate_program_parameters(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);
  {
    try {
      Ogre::GpuProgramTranslator::translateProgramParameters(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuProgramTranslator(Ogre::GpuProgramTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::SharedParamsTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::SharedParamsTranslator class


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


/*
  Document-method: Ogre::SharedParamsTranslator.new

  call-seq:
    SharedParamsTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SharedParamsTranslator *)new Ogre::SharedParamsTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SharedParamsTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SharedParamsTranslator(Ogre::SharedParamsTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ParticleSystemTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::ParticleSystemTranslator class


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


/*
  Document-method: Ogre::ParticleSystemTranslator.new

  call-seq:
    ParticleSystemTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ParticleSystemTranslator *)new Ogre::ParticleSystemTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystemTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleSystemTranslator(Ogre::ParticleSystemTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ParticleEmitterTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::ParticleEmitterTranslator class


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


/*
  Document-method: Ogre::ParticleEmitterTranslator.new

  call-seq:
    ParticleEmitterTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ParticleEmitterTranslator *)new Ogre::ParticleEmitterTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleEmitterTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleEmitterTranslator(Ogre::ParticleEmitterTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::ParticleAffectorTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::ParticleAffectorTranslator class


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


/*
  Document-method: Ogre::ParticleAffectorTranslator.new

  call-seq:
    ParticleAffectorTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ParticleAffectorTranslator *)new Ogre::ParticleAffectorTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleAffectorTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleAffectorTranslator(Ogre::ParticleAffectorTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CompositorTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::CompositorTranslator class


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


/*
  Document-method: Ogre::CompositorTranslator.new

  call-seq:
    CompositorTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::CompositorTranslator *)new Ogre::CompositorTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositorTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositorTranslator(Ogre::CompositorTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CompositionTechniqueTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::CompositionTechniqueTranslator class


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


/*
  Document-method: Ogre::CompositionTechniqueTranslator.new

  call-seq:
    CompositionTechniqueTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::CompositionTechniqueTranslator *)new Ogre::CompositionTechniqueTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTechniqueTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositionTechniqueTranslator(Ogre::CompositionTechniqueTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CompositionTargetPassTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::CompositionTargetPassTranslator class


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


/*
  Document-method: Ogre::CompositionTargetPassTranslator.new

  call-seq:
    CompositionTargetPassTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::CompositionTargetPassTranslator *)new Ogre::CompositionTargetPassTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionTargetPassTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositionTargetPassTranslator(Ogre::CompositionTargetPassTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::CompositionPassTranslator < Ogre::Ogre::ScriptTranslator

  Proxy of C++ Ogre::CompositionPassTranslator class


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


/*
  Document-method: Ogre::CompositionPassTranslator.new

  call-seq:
    CompositionPassTranslator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::CompositionPassTranslator *)new Ogre::CompositionPassTranslator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::CompositionPassTranslator.translate

  call-seq:
    translate(ScriptCompiler compiler, AbstractNodePtr node)

An instance method.

*/
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);
  {
    try {
      (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositionPassTranslator(Ogre::CompositionPassTranslator *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::BuiltinScriptTranslatorManager < Ogre::Ogre::ScriptTranslatorManager

  Proxy of C++ Ogre::BuiltinScriptTranslatorManager class


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


/*
  Document-method: Ogre::BuiltinScriptTranslatorManager.new

  call-seq:
    BuiltinScriptTranslatorManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::BuiltinScriptTranslatorManager *)new Ogre::BuiltinScriptTranslatorManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BuiltinScriptTranslatorManager.get_num_translators

  call-seq:
    get_num_translators -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_BuiltinScriptTranslatorManager_get_num_translators(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);
  {
    try {
      result = ((Ogre::BuiltinScriptTranslatorManager const *)arg1)->getNumTranslators();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BuiltinScriptTranslatorManager.get_translator

  call-seq:
    get_translator(AbstractNodePtr node) -> ScriptTranslator

An instance method.

*/
SWIGINTERN VALUE
_wrap_BuiltinScriptTranslatorManager_get_translator(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);
  {
    try {
      result = (Ogre::ScriptTranslator *)(arg1)->getTranslator((Ogre::AbstractNodePtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptTranslator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_BuiltinScriptTranslatorManager(Ogre::BuiltinScriptTranslatorManager *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::FocusedShadowCameraSetup < Ogre::Ogre::ShadowCameraSetup

  Proxy of C++ Ogre::FocusedShadowCameraSetup class


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


/*
  Document-method: Ogre::FocusedShadowCameraSetup.new

  call-seq:
    FocusedShadowCameraSetup.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::FocusedShadowCameraSetup *)new Ogre::FocusedShadowCameraSetup();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FocusedShadowCameraSetup(Ogre::FocusedShadowCameraSetup *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::FocusedShadowCameraSetup.get_shadow_camera

  call-seq:
    get_shadow_camera(SceneManager sm, Camera cam, Viewport vp, Light light, 
    Camera texCam, size_t iteration)

An instance method.

*/
SWIGINTERN VALUE
_wrap_FocusedShadowCameraSetup_get_shadow_camera(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);
  {
    try {
      ((Ogre::FocusedShadowCameraSetup const *)arg1)->getShadowCamera((Ogre::SceneManager const *)arg2,(Ogre::Camera const *)arg3,(Ogre::Viewport const *)arg4,(Ogre::Light const *)arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FocusedShadowCameraSetup.set_use_aggressive_focus_region

  call-seq:
    set_use_aggressive_focus_region(bool aggressive)

An instance method.

*/
SWIGINTERN VALUE
_wrap_FocusedShadowCameraSetup_set_use_aggressive_focus_region(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);
  {
    try {
      (arg1)->setUseAggressiveFocusRegion(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::FocusedShadowCameraSetup.get_use_aggressive_focus_region

  call-seq:
    get_use_aggressive_focus_region -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_FocusedShadowCameraSetup_get_use_aggressive_focus_region(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);
  {
    try {
      result = (bool)((Ogre::FocusedShadowCameraSetup const *)arg1)->getUseAggressiveFocusRegion();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::LiSPSMShadowCameraSetup < Ogre::Ogre::FocusedShadowCameraSetup

  Proxy of C++ Ogre::LiSPSMShadowCameraSetup class


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


/*
  Document-method: Ogre::LiSPSMShadowCameraSetup.new

  call-seq:
    LiSPSMShadowCameraSetup.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::LiSPSMShadowCameraSetup *)new Ogre::LiSPSMShadowCameraSetup();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_LiSPSMShadowCameraSetup(Ogre::LiSPSMShadowCameraSetup *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::LiSPSMShadowCameraSetup.get_shadow_camera

  call-seq:
    get_shadow_camera(SceneManager sm, Camera cam, Viewport vp, Light light, 
    Camera texCam, size_t iteration)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_get_shadow_camera(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);
  {
    try {
      ((Ogre::LiSPSMShadowCameraSetup const *)arg1)->getShadowCamera((Ogre::SceneManager const *)arg2,(Ogre::Camera const *)arg3,(Ogre::Viewport const *)arg4,(Ogre::Light const *)arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LiSPSMShadowCameraSetup.set_optimal_adjust_factor

  call-seq:
    set_optimal_adjust_factor(Real n)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_set_optimal_adjust_factor(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);
  {
    try {
      (arg1)->setOptimalAdjustFactor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LiSPSMShadowCameraSetup.get_optimal_adjust_factor

  call-seq:
    get_optimal_adjust_factor -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_get_optimal_adjust_factor(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);
  {
    try {
      result = (Ogre::Real)((Ogre::LiSPSMShadowCameraSetup const *)arg1)->getOptimalAdjustFactor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LiSPSMShadowCameraSetup.set_use_simple_optimal_adjust

  call-seq:
    set_use_simple_optimal_adjust(bool s)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_set_use_simple_optimal_adjust(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);
  {
    try {
      (arg1)->setUseSimpleOptimalAdjust(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LiSPSMShadowCameraSetup.get_use_simple_optimal_adjust

  call-seq:
    get_use_simple_optimal_adjust -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_get_use_simple_optimal_adjust(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);
  {
    try {
      result = (bool)((Ogre::LiSPSMShadowCameraSetup const *)arg1)->getUseSimpleOptimalAdjust();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LiSPSMShadowCameraSetup.set_camera_light_direction_threshold

  call-seq:
    set_camera_light_direction_threshold(Degree angle)

An instance method.

*/
SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_set_camera_light_direction_threshold(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));
    }
  }
  {
    try {
      (arg1)->setCameraLightDirectionThreshold(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LiSPSMShadowCameraSetup.get_camera_light_direction_threshold

  call-seq:
    get_camera_light_direction_threshold -> Degree

An instance method.

*/
SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_get_camera_light_direction_threshold(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);
  {
    try {
      result = ((Ogre::LiSPSMShadowCameraSetup const *)arg1)->getCameraLightDirectionThreshold();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PSSMShadowCameraSetup < Ogre::Ogre::LiSPSMShadowCameraSetup

  Proxy of C++ Ogre::PSSMShadowCameraSetup class


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


/*
  Document-method: Ogre::PSSMShadowCameraSetup.new

  call-seq:
    PSSMShadowCameraSetup.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PSSMShadowCameraSetup *)new Ogre::PSSMShadowCameraSetup();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PSSMShadowCameraSetup(Ogre::PSSMShadowCameraSetup *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PSSMShadowCameraSetup.calculate_split_points

  call-seq:
    calculate_split_points(size_t splitCount, Real nearDist, Real farDist, Real lambda=0.95)
    calculate_split_points(size_t splitCount, Real nearDist, Real farDist)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_calculate_split_points__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);
  {
    try {
      (arg1)->calculateSplitPoints(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_calculate_split_points__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);
  {
    try {
      (arg1)->calculateSplitPoints(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PSSMShadowCameraSetup_calculate_split_points(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_calculate_split_points__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_calculate_split_points__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "PSSMShadowCameraSetup.calculate_split_points", 
    "    void PSSMShadowCameraSetup.calculate_split_points(size_t splitCount, Ogre::Real nearDist, Ogre::Real farDist, Ogre::Real lambda)\n"
    "    void PSSMShadowCameraSetup.calculate_split_points(size_t splitCount, Ogre::Real nearDist, Ogre::Real farDist)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PSSMShadowCameraSetup.set_split_points

  call-seq:
    set_split_points(SplitPointList newSplitPoints)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_set_split_points(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);
  {
    try {
      (arg1)->setSplitPoints((Ogre::PSSMShadowCameraSetup::SplitPointList const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PSSMShadowCameraSetup.set_optimal_adjust_factor

  call-seq:
    set_optimal_adjust_factor(size_t splitIndex, Real factor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_set_optimal_adjust_factor(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);
  {
    try {
      (arg1)->setOptimalAdjustFactor(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PSSMShadowCameraSetup.set_split_padding

  call-seq:
    set_split_padding(Real pad)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_set_split_padding(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);
  {
    try {
      (arg1)->setSplitPadding(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PSSMShadowCameraSetup.get_split_padding

  call-seq:
    get_split_padding -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_get_split_padding(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);
  {
    try {
      result = (Ogre::Real)((Ogre::PSSMShadowCameraSetup const *)arg1)->getSplitPadding();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PSSMShadowCameraSetup.get_split_count

  call-seq:
    get_split_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_get_split_count(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);
  {
    try {
      result = ((Ogre::PSSMShadowCameraSetup const *)arg1)->getSplitCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PSSMShadowCameraSetup.get_shadow_camera

  call-seq:
    get_shadow_camera(SceneManager sm, Camera cam, Viewport vp, Light light, 
    Camera texCam, size_t iteration)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_get_shadow_camera(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);
  {
    try {
      ((Ogre::PSSMShadowCameraSetup const *)arg1)->getShadowCamera((Ogre::SceneManager const *)arg2,(Ogre::Camera const *)arg3,(Ogre::Viewport const *)arg4,(Ogre::Light const *)arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PSSMShadowCameraSetup.get_split_points

  call-seq:
    get_split_points -> SplitPointList

An instance method.

*/
SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_get_split_points(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);
  {
    try {
      result = (Ogre::PSSMShadowCameraSetup::SplitPointList *) &((Ogre::PSSMShadowCameraSetup const *)arg1)->getSplitPoints();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PSSMShadowCameraSetup.get_optimal_adjust_factor

  call-seq:
    get_optimal_adjust_factor(size_t splitIndex) -> Real
    get_optimal_adjust_factor -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_get_optimal_adjust_factor__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);
  {
    try {
      result = (Ogre::Real)((Ogre::PSSMShadowCameraSetup const *)arg1)->getOptimalAdjustFactor(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_get_optimal_adjust_factor__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);
  {
    try {
      result = (Ogre::Real)((Ogre::PSSMShadowCameraSetup const *)arg1)->getOptimalAdjustFactor();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PSSMShadowCameraSetup_get_optimal_adjust_factor(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_get_optimal_adjust_factor__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_get_optimal_adjust_factor__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PSSMShadowCameraSetup.get_optimal_adjust_factor", 
    "    Ogre::Real PSSMShadowCameraSetup.get_optimal_adjust_factor(size_t splitIndex)\n"
    "    Ogre::Real PSSMShadowCameraSetup.get_optimal_adjust_factor()\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::PlaneOptimalShadowCameraSetup < Ogre::Ogre::ShadowCameraSetup

  Proxy of C++ Ogre::PlaneOptimalShadowCameraSetup class


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


/*
  Document-method: Ogre::PlaneOptimalShadowCameraSetup.new

  call-seq:
    PlaneOptimalShadowCameraSetup.new(MovablePlane plane)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::PlaneOptimalShadowCameraSetup *)new Ogre::PlaneOptimalShadowCameraSetup(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PlaneOptimalShadowCameraSetup(Ogre::PlaneOptimalShadowCameraSetup *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PlaneOptimalShadowCameraSetup.get_shadow_camera

  call-seq:
    get_shadow_camera(SceneManager sm, Camera cam, Viewport vp, Light light, 
    Camera texCam, size_t iteration)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PlaneOptimalShadowCameraSetup_get_shadow_camera(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);
  {
    try {
      ((Ogre::PlaneOptimalShadowCameraSetup const *)arg1)->getShadowCamera((Ogre::SceneManager const *)arg2,(Ogre::Camera const *)arg3,(Ogre::Viewport const *)arg4,(Ogre::Light const *)arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ShadowVolumeExtrudeProgram

  Proxy of C++ Ogre::ShadowVolumeExtrudeProgram class


*/
swig_class SwigClassShadowVolumeExtrudeProgram;


/*
  Document-method: Ogre::Programs.POINT_LIGHT

  call-seq:
    POINT_LIGHT -> int

A class method.

*/

/*
  Document-method: Ogre::Programs.POINT_LIGHT_DEBUG

  call-seq:
    POINT_LIGHT_DEBUG -> int

A class method.

*/

/*
  Document-method: Ogre::Programs.DIRECTIONAL_LIGHT

  call-seq:
    DIRECTIONAL_LIGHT -> int

A class method.

*/

/*
  Document-method: Ogre::Programs.DIRECTIONAL_LIGHT_DEBUG

  call-seq:
    DIRECTIONAL_LIGHT_DEBUG -> int

A class method.

*/

/*
  Document-method: Ogre::Programs.POINT_LIGHT_FINITE

  call-seq:
    POINT_LIGHT_FINITE -> int

A class method.

*/

/*
  Document-method: Ogre::Programs.POINT_LIGHT_FINITE_DEBUG

  call-seq:
    POINT_LIGHT_FINITE_DEBUG -> int

A class method.

*/

/*
  Document-method: Ogre::Programs.DIRECTIONAL_LIGHT_FINITE

  call-seq:
    DIRECTIONAL_LIGHT_FINITE -> int

A class method.

*/

/*
  Document-method: Ogre::Programs.DIRECTIONAL_LIGHT_FINITE_DEBUG

  call-seq:
    DIRECTIONAL_LIGHT_FINITE_DEBUG -> int

A class method.

*/

/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.programNames

  call-seq:
    programNames -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.ShadowVolumeExtrudeProgram_programNames

  call-seq:
    ShadowVolumeExtrudeProgram_programNames -> String

Get value of attribute.

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



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.frgProgramName

  call-seq:
    frgProgramName -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.frgProgramName=

  call-seq:
    frgProgramName=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.ShadowVolumeExtrudeProgram_frgProgramName

  call-seq:
    ShadowVolumeExtrudeProgram_frgProgramName -> String

Get value of attribute.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_frgProgramName_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::ShadowVolumeExtrudeProgram::frgProgramName));
  return _val;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.ShadowVolumeExtrudeProgram_frgProgramName=

  call-seq:
    ShadowVolumeExtrudeProgram_frgProgramName=(x) -> String

Set new value for attribute.

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



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.initialise

  call-seq:
    initialise

A class method.

*/
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;
  }
  {
    try {
      Ogre::ShadowVolumeExtrudeProgram::initialise();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.shutdown

  call-seq:
    shutdown

A class method.

*/
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;
  }
  {
    try {
      Ogre::ShadowVolumeExtrudeProgram::shutdown();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_arbvp1

  call-seq:
    get_point_light_extruder_arbvp1 -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_arbvp1(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderArbvp1();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_vs_1_1

  call-seq:
    get_point_light_extruder_vs_1_1 -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_1_1();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_vs_4_0

  call-seq:
    get_point_light_extruder_vs_4_0 -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_4_0();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_vs_glsles

  call-seq:
    get_point_light_extruder_vs_glsles -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_glsles();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_arbvp1

  call-seq:
    get_directional_light_extruder_arbvp1 -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_arbvp1(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderArbvp1();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_vs_1_1

  call-seq:
    get_directional_light_extruder_vs_1_1 -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_1_1();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_vs_4_0

  call-seq:
    get_directional_light_extruder_vs_4_0 -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_4_0();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_vs_glsles

  call-seq:
    get_directional_light_extruder_vs_glsles -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_glsles();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_arbvp_1debug

  call-seq:
    get_point_light_extruder_arbvp_1debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_arbvp_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderArbvp1Debug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_vs_1_1debug

  call-seq:
    get_point_light_extruder_vs_1_1debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_1_1Debug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_vs_4_0debug

  call-seq:
    get_point_light_extruder_vs_4_0debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_4_0Debug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_vs_glsles_debug

  call-seq:
    get_point_light_extruder_vs_glsles_debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_glsles_debug(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_glslesDebug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_arbvp_1debug

  call-seq:
    get_directional_light_extruder_arbvp_1debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_arbvp_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderArbvp1Debug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_vs_1_1debug

  call-seq:
    get_directional_light_extruder_vs_1_1debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_1_1Debug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_vs_4_0debug

  call-seq:
    get_directional_light_extruder_vs_4_0debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_4_0Debug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_vs_glsles_debug

  call-seq:
    get_directional_light_extruder_vs_glsles_debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_glsles_debug(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_glslesDebug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_program_source

  call-seq:
    get_program_source(LightTypes lightType, String syntax, bool finite, bool debug) -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_program_source(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);
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getProgramSource(arg1,arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_program_name

  call-seq:
    get_program_name(LightTypes lightType, bool finite, bool debug) -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_program_name(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);
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getProgramName(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_arbvp_1finite

  call-seq:
    get_point_light_extruder_arbvp_1finite -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_arbvp_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderArbvp1Finite();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_vs_1_1finite

  call-seq:
    get_point_light_extruder_vs_1_1finite -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_1_1Finite();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_vs_4_0finite

  call-seq:
    get_point_light_extruder_vs_4_0finite -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_4_0Finite();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_vs_glsles_finite

  call-seq:
    get_point_light_extruder_vs_glsles_finite -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_glsles_finite(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_glslesFinite();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_arbvp_1finite

  call-seq:
    get_directional_light_extruder_arbvp_1finite -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_arbvp_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderArbvp1Finite();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_vs_1_1finite

  call-seq:
    get_directional_light_extruder_vs_1_1finite -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_1_1Finite();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_vs_4_0finite

  call-seq:
    get_directional_light_extruder_vs_4_0finite -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_4_0Finite();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_vs_glsles_finite

  call-seq:
    get_directional_light_extruder_vs_glsles_finite -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_glsles_finite(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_glslesFinite();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_arbvp_1finite_debug

  call-seq:
    get_point_light_extruder_arbvp_1finite_debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_arbvp_1finite_debug(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderArbvp1FiniteDebug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_vs_1_1finite_debug

  call-seq:
    get_point_light_extruder_vs_1_1finite_debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_1_1finite_debug(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_1_1FiniteDebug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_vs_4_0finite_debug

  call-seq:
    get_point_light_extruder_vs_4_0finite_debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_4_0finite_debug(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_4_0FiniteDebug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_point_light_extruder_vs_glsles_finite_debug

  call-seq:
    get_point_light_extruder_vs_glsles_finite_debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_glsles_finite_debug(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_glslesFiniteDebug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_arbvp_1finite_debug

  call-seq:
    get_directional_light_extruder_arbvp_1finite_debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_arbvp_1finite_debug(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderArbvp1FiniteDebug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_vs_1_1finite_debug

  call-seq:
    get_directional_light_extruder_vs_1_1finite_debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_1_1finite_debug(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_1_1FiniteDebug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_vs_4_0finite_debug

  call-seq:
    get_directional_light_extruder_vs_4_0finite_debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_4_0finite_debug(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_4_0FiniteDebug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.get_directional_light_extruder_vs_glsles_finite_debug

  call-seq:
    get_directional_light_extruder_vs_glsles_finite_debug -> String

A class method.

*/
SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_glsles_finite_debug(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;
  }
  {
    try {
      result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_glslesFiniteDebug();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


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


/*
  Document-method: Ogre::ShadowVolumeExtrudeProgram.new

  call-seq:
    ShadowVolumeExtrudeProgram.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::ShadowVolumeExtrudeProgram *)new Ogre::ShadowVolumeExtrudeProgram();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ShadowVolumeExtrudeProgram(Ogre::ShadowVolumeExtrudeProgram *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::SkeletonManager < Ogre::Ogre::ResourceManager

  Proxy of C++ Ogre::SkeletonManager class


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


/*
  Document-method: Ogre::SkeletonManager.new

  call-seq:
    SkeletonManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SkeletonManager *)new Ogre::SkeletonManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SkeletonManager(Ogre::SkeletonManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SkeletonManager.get_singleton

  call-seq:
    get_singleton -> SkeletonManager

A class method.

*/
SWIGINTERN VALUE
_wrap_SkeletonManager_get_singleton(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;
  }
  {
    try {
      result = (Ogre::SkeletonManager *) &Ogre::SkeletonManager::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonManager.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> SkeletonManager

A class method.

*/
SWIGINTERN VALUE
_wrap_SkeletonManager_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::SkeletonManager *)Ogre::SkeletonManager::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::SkeletonSerializer < Ogre::Ogre::Serializer

  Proxy of C++ Ogre::SkeletonSerializer class


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


/*
  Document-method: Ogre::SkeletonSerializer.new

  call-seq:
    SkeletonSerializer.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SkeletonSerializer *)new Ogre::SkeletonSerializer();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SkeletonSerializer(Ogre::SkeletonSerializer *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SkeletonSerializer.export_skeleton

  call-seq:
    export_skeleton(Skeleton pSkeleton, String filename, SkeletonVersion ver=SKELETON_VERSION_LATEST, 
    Endian endianMode=ENDIAN_NATIVE)
    export_skeleton(Skeleton pSkeleton, String filename, SkeletonVersion ver=SKELETON_VERSION_LATEST)
    export_skeleton(Skeleton pSkeleton, String filename)
    export_skeleton(Skeleton pSkeleton, DataStreamPtr stream, SkeletonVersion ver=SKELETON_VERSION_LATEST, 
    Endian endianMode=ENDIAN_NATIVE)
    export_skeleton(Skeleton pSkeleton, DataStreamPtr stream, SkeletonVersion ver=SKELETON_VERSION_LATEST)
    export_skeleton(Skeleton pSkeleton, DataStreamPtr stream)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonSerializer_export_skeleton__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);
  {
    try {
      (arg1)->exportSkeleton((Ogre::Skeleton const *)arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonSerializer_export_skeleton__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);
  {
    try {
      (arg1)->exportSkeleton((Ogre::Skeleton const *)arg2,(Ogre::String const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonSerializer_export_skeleton__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;
  }
  {
    try {
      (arg1)->exportSkeleton((Ogre::Skeleton const *)arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonSerializer_export_skeleton__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);
  {
    try {
      (arg1)->exportSkeleton((Ogre::Skeleton const *)arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonSerializer_export_skeleton__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);
  {
    try {
      (arg1)->exportSkeleton((Ogre::Skeleton const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonSerializer_export_skeleton__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));
    }
  }
  {
    try {
      (arg1)->exportSkeleton((Ogre::Skeleton const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SkeletonSerializer_export_skeleton(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_export_skeleton__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_export_skeleton__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_export_skeleton__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_export_skeleton__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_export_skeleton__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_export_skeleton__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "SkeletonSerializer.export_skeleton", 
    "    void SkeletonSerializer.export_skeleton(Ogre::Skeleton const *pSkeleton, Ogre::String const &filename, Ogre::SkeletonVersion ver, Ogre::Serializer::Endian endianMode)\n"
    "    void SkeletonSerializer.export_skeleton(Ogre::Skeleton const *pSkeleton, Ogre::String const &filename, Ogre::SkeletonVersion ver)\n"
    "    void SkeletonSerializer.export_skeleton(Ogre::Skeleton const *pSkeleton, Ogre::String const &filename)\n"
    "    void SkeletonSerializer.export_skeleton(Ogre::Skeleton const *pSkeleton, Ogre::DataStreamPtr stream, Ogre::SkeletonVersion ver, Ogre::Serializer::Endian endianMode)\n"
    "    void SkeletonSerializer.export_skeleton(Ogre::Skeleton const *pSkeleton, Ogre::DataStreamPtr stream, Ogre::SkeletonVersion ver)\n"
    "    void SkeletonSerializer.export_skeleton(Ogre::Skeleton const *pSkeleton, Ogre::DataStreamPtr stream)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SkeletonSerializer.import_skeleton

  call-seq:
    import_skeleton(DataStreamPtr stream, Skeleton pDest)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SkeletonSerializer_import_skeleton(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);
  {
    try {
      (arg1)->importSkeleton(*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



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

  call-seq:
    SPOT_SHADOW_FADE_PNG -> unsigned char

Get value of attribute.

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



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

  call-seq:
    SPOT_SHADOW_FADE_PNG=(x) -> unsigned char

Set new value for attribute.

*/
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;
}



/*
  Document-class: Ogre::StaticFaceGroup

  Proxy of C++ Ogre::StaticFaceGroup class


*/
swig_class SwigClassStaticFaceGroup;


/*
  Document-method: Ogre::StaticFaceGroup.fType

  call-seq:
    fType -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::StaticFaceGroup.fType=

  call-seq:
    fType=(x) -> int

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::StaticFaceGroup.isSky

  call-seq:
    isSky -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::StaticFaceGroup.isSky=

  call-seq:
    isSky=(x) -> bool

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::StaticFaceGroup.vertexStart

  call-seq:
    vertexStart -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::StaticFaceGroup.vertexStart=

  call-seq:
    vertexStart=(x) -> int

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::StaticFaceGroup.numVertices

  call-seq:
    numVertices -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::StaticFaceGroup.numVertices=

  call-seq:
    numVertices=(x) -> int

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::StaticFaceGroup.elementStart

  call-seq:
    elementStart -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::StaticFaceGroup.elementStart=

  call-seq:
    elementStart=(x) -> int

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::StaticFaceGroup.numElements

  call-seq:
    numElements -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::StaticFaceGroup.numElements=

  call-seq:
    numElements=(x) -> int

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::StaticFaceGroup.materialHandle

  call-seq:
    materialHandle -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::StaticFaceGroup.materialHandle=

  call-seq:
    materialHandle=(x) -> int

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::StaticFaceGroup.plane

  call-seq:
    plane -> Plane

Get value of attribute.

*/

/*
  Document-method: Ogre::StaticFaceGroup.plane=

  call-seq:
    plane=(x) -> Plane

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::StaticFaceGroup.patchSurf

  call-seq:
    patchSurf -> PatchSurface

Get value of attribute.

*/

/*
  Document-method: Ogre::StaticFaceGroup.patchSurf=

  call-seq:
    patchSurf=(x) -> PatchSurface

Set new value for attribute.

*/
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;
  }
  


/*
  Document-method: Ogre::StaticFaceGroup.new

  call-seq:
    StaticFaceGroup.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::StaticFaceGroup *)new Ogre::StaticFaceGroup();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_StaticFaceGroup(Ogre::StaticFaceGroup *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::StaticGeometry

  Proxy of C++ Ogre::StaticGeometry class


*/
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;
  }
  


/*
  Document-method: Ogre::StaticGeometry.new

  call-seq:
    StaticGeometry.new(SceneManager owner, String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::StaticGeometry *)new Ogre::StaticGeometry(arg1,(Ogre::String const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::StaticGeometry.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::StaticGeometry const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.add_entity

  call-seq:
    add_entity(Entity ent, Vector3 position, Quaternion orientation=IDENTITY, 
    Vector3 scale=UNIT_SCALE)
    add_entity(Entity ent, Vector3 position, Quaternion orientation=IDENTITY)
    add_entity(Entity ent, Vector3 position)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_add_entity__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);
  {
    try {
      (arg1)->addEntity(arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4,(Ogre::Vector3 const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_add_entity__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);
  {
    try {
      (arg1)->addEntity(arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_add_entity__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);
  {
    try {
      (arg1)->addEntity(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StaticGeometry_add_entity(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_add_entity__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_add_entity__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_add_entity__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "StaticGeometry.add_entity", 
    "    void StaticGeometry.add_entity(Ogre::Entity *ent, Ogre::Vector3 const &position, Ogre::Quaternion const &orientation, Ogre::Vector3 const &scale)\n"
    "    void StaticGeometry.add_entity(Ogre::Entity *ent, Ogre::Vector3 const &position, Ogre::Quaternion const &orientation)\n"
    "    void StaticGeometry.add_entity(Ogre::Entity *ent, Ogre::Vector3 const &position)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.add_scene_node

  call-seq:
    add_scene_node(SceneNode node)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_add_scene_node(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);
  {
    try {
      (arg1)->addSceneNode((Ogre::SceneNode const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.build

  call-seq:
    build

An instance method.

*/
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);
  {
    try {
      (arg1)->build();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.destroy

  call-seq:
    destroy

An instance method.

*/
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);
  {
    try {
      (arg1)->destroy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.reset

  call-seq:
    reset

An instance method.

*/
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);
  {
    try {
      (arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.set_rendering_distance

  call-seq:
    set_rendering_distance(Real dist)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_set_rendering_distance(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);
  {
    try {
      (arg1)->setRenderingDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.get_rendering_distance

  call-seq:
    get_rendering_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_get_rendering_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::StaticGeometry const *)arg1)->getRenderingDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.get_squared_rendering_distance

  call-seq:
    get_squared_rendering_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_get_squared_rendering_distance(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);
  {
    try {
      result = (Ogre::Real)((Ogre::StaticGeometry const *)arg1)->getSquaredRenderingDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.set_visible

  call-seq:
    set_visible(bool visible)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_set_visible(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);
  {
    try {
      (arg1)->setVisible(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.is_visible

  call-seq:
    is_visible -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_is_visible(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);
  {
    try {
      result = (bool)((Ogre::StaticGeometry const *)arg1)->isVisible();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.set_cast_shadows

  call-seq:
    set_cast_shadows(bool castShadows)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_set_cast_shadows(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);
  {
    try {
      (arg1)->setCastShadows(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.get_cast_shadows

  call-seq:
    get_cast_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_get_cast_shadows(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);
  {
    try {
      result = (bool)(arg1)->getCastShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.set_region_dimensions

  call-seq:
    set_region_dimensions(Vector3 size)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_set_region_dimensions(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);
  {
    try {
      (arg1)->setRegionDimensions((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.get_region_dimensions

  call-seq:
    get_region_dimensions -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_get_region_dimensions(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::StaticGeometry const *)arg1)->getRegionDimensions();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.set_origin

  call-seq:
    set_origin(Vector3 origin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_set_origin(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);
  {
    try {
      (arg1)->setOrigin((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.get_origin

  call-seq:
    get_origin -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_get_origin(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::StaticGeometry const *)arg1)->getOrigin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.set_visibility_flags

  call-seq:
    set_visibility_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_set_visibility_flags(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);
  {
    try {
      (arg1)->setVisibilityFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.get_visibility_flags

  call-seq:
    get_visibility_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_get_visibility_flags(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::StaticGeometry const *)arg1)->getVisibilityFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.set_render_queue_group

  call-seq:
    set_render_queue_group(uint8 queueID)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_set_render_queue_group(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);
  {
    try {
      (arg1)->setRenderQueueGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.get_render_queue_group

  call-seq:
    get_render_queue_group -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_get_render_queue_group(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::StaticGeometry const *)arg1)->getRenderQueueGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.visit_renderables

  call-seq:
    visit_renderables(Visitor visitor, bool debugRenderables=false)
    visit_renderables(Visitor visitor)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_visit_renderables__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);
  {
    try {
      (arg1)->visitRenderables(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StaticGeometry_visit_renderables(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_visit_renderables__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_visit_renderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "StaticGeometry.visit_renderables", 
    "    void StaticGeometry.visit_renderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void StaticGeometry.visit_renderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StaticGeometry.get_region_iterator

  call-seq:
    get_region_iterator -> RegionIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_StaticGeometry_get_region_iterator(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);
  {
    try {
      result = (arg1)->getRegionIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::StaticGeometry.dump

  call-seq:
    dump(String filename)

An instance method.

*/
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;
  }
  {
    try {
      ((Ogre::StaticGeometry const *)arg1)->dump((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-class: Ogre::StaticPluginLoader

  Proxy of C++ Ogre::StaticPluginLoader class


*/
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;
  }
  


/*
  Document-method: Ogre::StaticPluginLoader.new

  call-seq:
    StaticPluginLoader.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::StaticPluginLoader *)new Ogre::StaticPluginLoader();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticPluginLoader.load

  call-seq:
    load

An instance method.

*/
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);
  {
    try {
      (arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StaticPluginLoader.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_StaticPluginLoader(Ogre::StaticPluginLoader *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::StreamSerialiser

  Proxy of C++ Ogre::StreamSerialiser class


*/
swig_class SwigClassStreamSerialiser;


/*
  Document-method: Ogre::Endian.ENDIAN_AUTO

  call-seq:
    ENDIAN_AUTO -> int

A class method.

*/

/*
  Document-method: Ogre::Endian.ENDIAN_BIG

  call-seq:
    ENDIAN_BIG -> int

A class method.

*/

/*
  Document-method: Ogre::Endian.ENDIAN_LITTLE

  call-seq:
    ENDIAN_LITTLE -> int

A class method.

*/

/*
  Document-method: Ogre::RealStorageFormat.REAL_FLOAT

  call-seq:
    REAL_FLOAT -> int

A class method.

*/

/*
  Document-method: Ogre::RealStorageFormat.REAL_DOUBLE

  call-seq:
    REAL_DOUBLE -> int

A class method.

*/

/*
  Document-method: Ogre::StreamSerialiser.new

  call-seq:
    StreamSerialiser.new(DataStreamPtr stream, Endian endianMode=ENDIAN_AUTO, 
    bool autoHeader=true, RealStorageFormat realFormat=REAL_FLOAT)
    StreamSerialiser.new(DataStreamPtr stream, Endian endianMode=ENDIAN_AUTO, 
    bool autoHeader=true)
    StreamSerialiser.new(DataStreamPtr stream, Endian endianMode=ENDIAN_AUTO)
    StreamSerialiser.new(DataStreamPtr stream)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::StreamSerialiser *)new Ogre::StreamSerialiser((Ogre::DataStreamPtr const &)*arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::StreamSerialiser *)new Ogre::StreamSerialiser((Ogre::DataStreamPtr const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_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);
  {
    try {
      result = (Ogre::StreamSerialiser *)new Ogre::StreamSerialiser((Ogre::DataStreamPtr const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::StreamSerialiser *)new Ogre::StreamSerialiser((Ogre::DataStreamPtr const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::StreamSerialiser.get_endian

  call-seq:
    get_endian -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_get_endian(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);
  {
    try {
      result = (Ogre::StreamSerialiser::Endian)((Ogre::StreamSerialiser const *)arg1)->getEndian();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.make_identifier

  call-seq:
    make_identifier(String code) -> uint32

A class method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_make_identifier(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;
  }
  {
    try {
      result = (Ogre::uint32)Ogre::StreamSerialiser::makeIdentifier((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_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;
}



/*
  Document-method: Ogre::StreamSerialiser.get_current_chunk_depth

  call-seq:
    get_current_chunk_depth -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_get_current_chunk_depth(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);
  {
    try {
      result = ((Ogre::StreamSerialiser const *)arg1)->getCurrentChunkDepth();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.get_current_chunk_id

  call-seq:
    get_current_chunk_id -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_get_current_chunk_id(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::StreamSerialiser const *)arg1)->getCurrentChunkID();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.get_offset_from_chunk_start

  call-seq:
    get_offset_from_chunk_start -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_get_offset_from_chunk_start(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);
  {
    try {
      result = ((Ogre::StreamSerialiser const *)arg1)->getOffsetFromChunkStart();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.read_chunk_begin

  call-seq:
    read_chunk_begin -> Chunk
    read_chunk_begin(uint32 id, uint16 maxVersion, String msg=BLANK) -> Chunk
    read_chunk_begin(uint32 id, uint16 maxVersion) -> Chunk

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_read_chunk_begin__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);
  {
    try {
      result = (Ogre::StreamSerialiser::Chunk *)(arg1)->readChunkBegin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser__Chunk, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read_chunk_begin__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;
  }
  {
    try {
      result = (Ogre::StreamSerialiser::Chunk *)(arg1)->readChunkBegin(arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_read_chunk_begin__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);
  {
    try {
      result = (Ogre::StreamSerialiser::Chunk *)(arg1)->readChunkBegin(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser__Chunk, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StreamSerialiser_read_chunk_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 == 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_read_chunk_begin__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_read_chunk_begin__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_read_chunk_begin__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "StreamSerialiser.read_chunk_begin", 
    "    Ogre::StreamSerialiser::Chunk const * StreamSerialiser.read_chunk_begin()\n"
    "    Ogre::StreamSerialiser::Chunk const * StreamSerialiser.read_chunk_begin(Ogre::uint32 id, Ogre::uint16 maxVersion, Ogre::String const &msg)\n"
    "    Ogre::StreamSerialiser::Chunk const * StreamSerialiser.read_chunk_begin(Ogre::uint32 id, Ogre::uint16 maxVersion)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.undo_read_chunk

  call-seq:
    undo_read_chunk(uint32 id)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_undo_read_chunk(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);
  {
    try {
      (arg1)->undoReadChunk(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.peek_next_chunk_id

  call-seq:
    peek_next_chunk_id -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_peek_next_chunk_id(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);
  {
    try {
      result = (Ogre::uint32)(arg1)->peekNextChunkID();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.read_chunk_end

  call-seq:
    read_chunk_end(uint32 id)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_read_chunk_end(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);
  {
    try {
      (arg1)->readChunkEnd(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.is_end_of_chunk

  call-seq:
    is_end_of_chunk(uint32 id) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_is_end_of_chunk(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);
  {
    try {
      result = (bool)(arg1)->isEndOfChunk(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.eof

  call-seq:
    eof -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)((Ogre::StreamSerialiser const *)arg1)->eof();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.get_current_chunk

  call-seq:
    get_current_chunk -> Chunk

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_get_current_chunk(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);
  {
    try {
      result = (Ogre::StreamSerialiser::Chunk *)((Ogre::StreamSerialiser const *)arg1)->getCurrentChunk();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser__Chunk, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.write_chunk_begin

  call-seq:
    write_chunk_begin(uint32 id, uint16 version=1)
    write_chunk_begin(uint32 id)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_write_chunk_begin__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);
  {
    try {
      (arg1)->writeChunkBegin(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write_chunk_begin__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);
  {
    try {
      (arg1)->writeChunkBegin(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StreamSerialiser_write_chunk_begin(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_write_chunk_begin__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_write_chunk_begin__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "StreamSerialiser.write_chunk_begin", 
    "    void StreamSerialiser.write_chunk_begin(Ogre::uint32 id, Ogre::uint16 version)\n"
    "    void StreamSerialiser.write_chunk_begin(Ogre::uint32 id)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.write_chunk_end

  call-seq:
    write_chunk_end(uint32 id)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_write_chunk_end(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);
  {
    try {
      (arg1)->writeChunkEnd(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.write_data

  call-seq:
    write_data(void buf, size_t size, size_t count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_write_data(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);
  {
    try {
      (arg1)->writeData((void const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.write

  call-seq:
    write(Real val, size_t count=1)
    write(Real val)
    write(Vector2 vec, size_t count=1)
    write(Vector2 vec)
    write(Vector3 vec, size_t count=1)
    write(Vector3 vec)
    write(Vector4 vec, size_t count=1)
    write(Vector4 vec)
    write(Quaternion q, size_t count=1)
    write(Quaternion q)
    write(Matrix3 m, size_t count=1)
    write(Matrix3 m)
    write(Matrix4 m, size_t count=1)
    write(Matrix4 m)
    write(String string)
    write(AxisAlignedBox aabb, size_t count=1)
    write(AxisAlignedBox aabb)
    write(Sphere sphere, size_t count=1)
    write(Sphere sphere)
    write(Plane plane, size_t count=1)
    write(Plane plane)
    write(Ray ray, size_t count=1)
    write(Ray ray)
    write(Radian angle, size_t count=1)
    write(Radian angle)
    write(Node node, size_t count=1)
    write(Node node)
    write(bool boolean, size_t count=1)
    write(bool boolean)

An instance method.

*/
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);
  {
    try {
      (arg1)->write((Ogre::Real const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Real const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Vector2 const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->write((Ogre::Vector2 const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->write((Ogre::Vector3 const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->write((Ogre::Vector3 const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->write((Ogre::Vector4 const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Vector4 const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Quaternion const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Quaternion const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->write((Ogre::Matrix3 const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Matrix3 const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Matrix4 const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Matrix4 const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      (arg1)->write((Ogre::String const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::AxisAlignedBox const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::AxisAlignedBox const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Sphere const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Sphere const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Plane const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Plane const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Ray const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Ray const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Radian const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Radian const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Node const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((Ogre::Node const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((bool const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->write((bool const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::StreamSerialiser.read_data

  call-seq:
    read_data(void buf, size_t size, size_t count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_StreamSerialiser_read_data(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);
  {
    try {
      (arg1)->readData(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::StreamSerialiser.read

  call-seq:
    read(Real val, size_t count=1)
    read(Real val)
    read(Vector2 vec, size_t count=1)
    read(Vector2 vec)
    read(Vector3 vec, size_t count=1)
    read(Vector3 vec)
    read(Vector4 vec, size_t count=1)
    read(Vector4 vec)
    read(Quaternion q, size_t count=1)
    read(Quaternion q)
    read(Matrix3 m, size_t count=1)
    read(Matrix3 m)
    read(Matrix4 m, size_t count=1)
    read(Matrix4 m)
    read(String string)
    read(AxisAlignedBox aabb, size_t count=1)
    read(AxisAlignedBox aabb)
    read(Sphere sphere, size_t count=1)
    read(Sphere sphere)
    read(Plane plane, size_t count=1)
    read(Plane plane)
    read(Ray ray, size_t count=1)
    read(Ray ray)
    read(Radian angle, size_t count=1)
    read(Radian angle)
    read(Node node, size_t count=1)
    read(Node node)
    read(bool val, size_t count=1)
    read(bool val)

An instance method.

*/
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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->read(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-class: Ogre::SubEntity < Ogre::Ogre::Renderable

  Proxy of C++ Ogre::SubEntity class


*/
swig_class SwigClassSubEntity;


/*
  Document-method: Ogre::SubEntity.get_material_name

  call-seq:
    get_material_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_material_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::SubEntity const *)arg1)->getMaterialName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.set_material_name

  call-seq:
    set_material_name(String name, String groupName=AUTODETECT_RESOURCE_GROUP_NAME)
    set_material_name(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SubEntity_set_material_name(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_set_material_name__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_set_material_name__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SubEntity.set_material_name", 
    "    void SubEntity.set_material_name(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    void SubEntity.set_material_name(Ogre::String const &name)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.set_material

  call-seq:
    set_material(MaterialPtr material)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_set_material(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);
  {
    try {
      (arg1)->setMaterial((Ogre::MaterialPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.set_visible

  call-seq:
    set_visible(bool visible)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_set_visible(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);
  {
    try {
      (arg1)->setVisible(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.is_visible

  call-seq:
    is_visible -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_is_visible(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);
  {
    try {
      result = (bool)((Ogre::SubEntity const *)arg1)->isVisible();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.set_render_queue_group

  call-seq:
    set_render_queue_group(uint8 queueID)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_set_render_queue_group(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);
  {
    try {
      (arg1)->setRenderQueueGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.set_render_queue_group_and_priority

  call-seq:
    set_render_queue_group_and_priority(uint8 queueID, ushort priority)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_set_render_queue_group_and_priority(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);
  {
    try {
      (arg1)->setRenderQueueGroupAndPriority(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_render_queue_group

  call-seq:
    get_render_queue_group -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_render_queue_group(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::SubEntity const *)arg1)->getRenderQueueGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_render_queue_priority

  call-seq:
    get_render_queue_priority -> ushort

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_render_queue_priority(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);
  {
    try {
      result = (Ogre::ushort)((Ogre::SubEntity const *)arg1)->getRenderQueuePriority();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.is_render_queue_group_set

  call-seq:
    is_render_queue_group_set -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_is_render_queue_group_set(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);
  {
    try {
      result = (bool)((Ogre::SubEntity const *)arg1)->isRenderQueueGroupSet();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.is_render_queue_priority_set

  call-seq:
    is_render_queue_priority_set -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_is_render_queue_priority_set(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);
  {
    try {
      result = (bool)((Ogre::SubEntity const *)arg1)->isRenderQueuePrioritySet();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_sub_mesh

  call-seq:
    get_sub_mesh -> SubMesh

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_sub_mesh(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);
  {
    try {
      result = (Ogre::SubMesh *)(arg1)->getSubMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_parent

  call-seq:
    get_parent -> Entity

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_parent(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);
  {
    try {
      result = (Ogre::Entity *)((Ogre::SubEntity const *)arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::SubEntity const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_technique

  call-seq:
    get_technique -> Technique

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_technique(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);
  {
    try {
      result = (Ogre::Technique *)((Ogre::SubEntity const *)arg1)->getTechnique();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_render_operation

  call-seq:
    get_render_operation(RenderOperation op)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_render_operation(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);
  {
    try {
      (arg1)->getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_world_transforms

  call-seq:
    get_world_transforms(Matrix4 xform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_world_transforms(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);
  {
    try {
      ((Ogre::SubEntity const *)arg1)->getWorldTransforms(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_num_world_transforms

  call-seq:
    get_num_world_transforms -> unsigned short

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_num_world_transforms(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);
  {
    try {
      result = (unsigned short)((Ogre::SubEntity const *)arg1)->getNumWorldTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera cam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::SubEntity const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_lights

  call-seq:
    get_lights -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_lights(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::SubEntity const *)arg1)->getLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_casts_shadows

  call-seq:
    get_casts_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_casts_shadows(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);
  {
    try {
      result = (bool)((Ogre::SubEntity const *)arg1)->getCastsShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity._get_skel_anim_vertex_data

  call-seq:
    _get_skel_anim_vertex_data -> VertexData

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity__get_skel_anim_vertex_data(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);
  {
    try {
      result = (Ogre::VertexData *)(arg1)->_getSkelAnimVertexData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity._get_software_vertex_anim_vertex_data

  call-seq:
    _get_software_vertex_anim_vertex_data -> VertexData

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity__get_software_vertex_anim_vertex_data(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);
  {
    try {
      result = (Ogre::VertexData *)(arg1)->_getSoftwareVertexAnimVertexData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity._get_hardware_vertex_anim_vertex_data

  call-seq:
    _get_hardware_vertex_anim_vertex_data -> VertexData

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity__get_hardware_vertex_anim_vertex_data(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);
  {
    try {
      result = (Ogre::VertexData *)(arg1)->_getHardwareVertexAnimVertexData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity._get_skel_anim_temp_buffer_info

  call-seq:
    _get_skel_anim_temp_buffer_info -> TempBlendedBufferInfo

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity__get_skel_anim_temp_buffer_info(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);
  {
    try {
      result = (Ogre::TempBlendedBufferInfo *)(arg1)->_getSkelAnimTempBufferInfo();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TempBlendedBufferInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity._get_vertex_anim_temp_buffer_info

  call-seq:
    _get_vertex_anim_temp_buffer_info -> TempBlendedBufferInfo

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity__get_vertex_anim_temp_buffer_info(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);
  {
    try {
      result = (Ogre::TempBlendedBufferInfo *)(arg1)->_getVertexAnimTempBufferInfo();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TempBlendedBufferInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity.get_vertex_data_for_binding

  call-seq:
    get_vertex_data_for_binding -> VertexData

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity_get_vertex_data_for_binding(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);
  {
    try {
      result = (Ogre::VertexData *)(arg1)->getVertexDataForBinding();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity._mark_buffers_unused_for_animation

  call-seq:
    _mark_buffers_unused_for_animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity__mark_buffers_unused_for_animation(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);
  {
    try {
      (arg1)->_markBuffersUnusedForAnimation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity._mark_buffers_used_for_animation

  call-seq:
    _mark_buffers_used_for_animation

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity__mark_buffers_used_for_animation(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);
  {
    try {
      (arg1)->_markBuffersUsedForAnimation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity._get_buffers_marked_for_animation

  call-seq:
    _get_buffers_marked_for_animation -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity__get_buffers_marked_for_animation(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);
  {
    try {
      result = (bool)((Ogre::SubEntity const *)arg1)->_getBuffersMarkedForAnimation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity._restore_buffers_for_unused_animation

  call-seq:
    _restore_buffers_for_unused_animation(bool hardwareAnimation)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity__restore_buffers_for_unused_animation(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);
  {
    try {
      (arg1)->_restoreBuffersForUnusedAnimation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity._update_custom_gpu_parameter

  call-seq:
    _update_custom_gpu_parameter(AutoConstantEntry constantEntry, GpuProgramParameters params)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity__update_custom_gpu_parameter(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);
  {
    try {
      ((Ogre::SubEntity const *)arg1)->_updateCustomGpuParameter((Ogre::GpuProgramParameters::AutoConstantEntry const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubEntity._invalidate_camera_cache

  call-seq:
    _invalidate_camera_cache

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubEntity__invalidate_camera_cache(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);
  {
    try {
      (arg1)->_invalidateCameraCache();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::SubMesh

  Proxy of C++ Ogre::SubMesh class


*/
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;
  }
  


/*
  Document-method: Ogre::SubMesh.new

  call-seq:
    SubMesh.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SubMesh *)new Ogre::SubMesh();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SubMesh(Ogre::SubMesh *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SubMesh.useSharedVertices

  call-seq:
    useSharedVertices -> bool

Get value of attribute.

*/

/*
  Document-method: Ogre::SubMesh.useSharedVertices=

  call-seq:
    useSharedVertices=(x) -> bool

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::SubMesh.operationType

  call-seq:
    operationType -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::SubMesh.operationType=

  call-seq:
    operationType=(x) -> int

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::SubMesh.vertexData

  call-seq:
    vertexData -> VertexData

Get value of attribute.

*/

/*
  Document-method: Ogre::SubMesh.vertexData=

  call-seq:
    vertexData=(x) -> VertexData

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::SubMesh.indexData

  call-seq:
    indexData -> IndexData

Get value of attribute.

*/

/*
  Document-method: Ogre::SubMesh.indexData=

  call-seq:
    indexData=(x) -> IndexData

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::SubMesh.blendIndexToBoneIndexMap

  call-seq:
    blendIndexToBoneIndexMap -> IndexMap

Get value of attribute.

*/

/*
  Document-method: Ogre::SubMesh.blendIndexToBoneIndexMap=

  call-seq:
    blendIndexToBoneIndexMap=(x) -> IndexMap

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::SubMesh.mLodFaceList

  call-seq:
    mLodFaceList -> LODFaceList

Get value of attribute.

*/

/*
  Document-method: Ogre::SubMesh.mLodFaceList=

  call-seq:
    mLodFaceList=(x) -> LODFaceList

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::SubMesh.extremityPoints

  call-seq:
    extremityPoints -> Ogre::vector<(Ogre::Vector3,Ogre::STLAllocator<(Ogre::Vector3,Ogre::GeneralAllocPolicy)>)>::type

Get value of attribute.

*/

/*
  Document-method: Ogre::SubMesh.extremityPoints=

  call-seq:
    extremityPoints=(x) -> Ogre::vector<(Ogre::Vector3,Ogre::STLAllocator<(Ogre::Vector3,Ogre::GeneralAllocPolicy)>)>::type

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::SubMesh.parent

  call-seq:
    parent -> Mesh

Get value of attribute.

*/

/*
  Document-method: Ogre::SubMesh.parent=

  call-seq:
    parent=(x) -> Mesh

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::SubMesh.set_material_name

  call-seq:
    set_material_name(String matName, String groupName=AUTODETECT_RESOURCE_GROUP_NAME)
    set_material_name(String matName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_set_material_name__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;
  }
  {
    try {
      (arg1)->setMaterialName((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SubMesh_set_material_name(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_set_material_name__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_set_material_name__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SubMesh.set_material_name", 
    "    void SubMesh.set_material_name(Ogre::String const &matName, Ogre::String const &groupName)\n"
    "    void SubMesh.set_material_name(Ogre::String const &matName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.get_material_name

  call-seq:
    get_material_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_get_material_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::SubMesh const *)arg1)->getMaterialName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.is_mat_initialised

  call-seq:
    is_mat_initialised -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_is_mat_initialised(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);
  {
    try {
      result = (bool)((Ogre::SubMesh const *)arg1)->isMatInitialised();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh._get_render_operation

  call-seq:
    _get_render_operation(RenderOperation rend, ushort lodIndex=0)
    _get_render_operation(RenderOperation rend)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh__get_render_operation__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);
  {
    try {
      (arg1)->_getRenderOperation(*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh__get_render_operation__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);
  {
    try {
      (arg1)->_getRenderOperation(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SubMesh__get_render_operation(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__get_render_operation__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__get_render_operation__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SubMesh._get_render_operation", 
    "    void SubMesh._get_render_operation(Ogre::RenderOperation &rend, Ogre::ushort lodIndex)\n"
    "    void SubMesh._get_render_operation(Ogre::RenderOperation &rend)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.add_bone_assignment

  call-seq:
    add_bone_assignment(VertexBoneAssignment vertBoneAssign)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_add_bone_assignment(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);
  {
    try {
      (arg1)->addBoneAssignment((Ogre::VertexBoneAssignment const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.clear_bone_assignments

  call-seq:
    clear_bone_assignments

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_clear_bone_assignments(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);
  {
    try {
      (arg1)->clearBoneAssignments();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.get_bone_assignment_iterator

  call-seq:
    get_bone_assignment_iterator -> BoneAssignmentIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_get_bone_assignment_iterator(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);
  {
    try {
      result = (arg1)->getBoneAssignmentIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::SubMesh.get_bone_assignments

  call-seq:
    get_bone_assignments -> VertexBoneAssignmentList

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_get_bone_assignments(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);
  {
    try {
      result = (Ogre::SubMesh::VertexBoneAssignmentList *) &(arg1)->getBoneAssignments();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::SubMesh._compile_bone_assignments

  call-seq:
    _compile_bone_assignments

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh__compile_bone_assignments(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);
  {
    try {
      (arg1)->_compileBoneAssignments();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.get_alias_texture_iterator

  call-seq:
    get_alias_texture_iterator -> AliasTextureIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_get_alias_texture_iterator(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);
  {
    try {
      result = ((Ogre::SubMesh const *)arg1)->getAliasTextureIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::SubMesh.add_texture_alias

  call-seq:
    add_texture_alias(String aliasName, String textureName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_add_texture_alias(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;
  }
  {
    try {
      (arg1)->addTextureAlias((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::SubMesh.remove_texture_alias

  call-seq:
    remove_texture_alias(String aliasName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_remove_texture_alias(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;
  }
  {
    try {
      (arg1)->removeTextureAlias((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.remove_all_texture_aliases

  call-seq:
    remove_all_texture_aliases

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_remove_all_texture_aliases(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);
  {
    try {
      (arg1)->removeAllTextureAliases();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.has_texture_aliases

  call-seq:
    has_texture_aliases -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_has_texture_aliases(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);
  {
    try {
      result = (bool)((Ogre::SubMesh const *)arg1)->hasTextureAliases();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.get_texture_alias_count

  call-seq:
    get_texture_alias_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_get_texture_alias_count(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);
  {
    try {
      result = ((Ogre::SubMesh const *)arg1)->getTextureAliasCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.update_material_using_texture_aliases

  call-seq:
    update_material_using_texture_aliases -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_update_material_using_texture_aliases(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);
  {
    try {
      result = (bool)(arg1)->updateMaterialUsingTextureAliases();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.get_vertex_animation_type

  call-seq:
    get_vertex_animation_type -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_get_vertex_animation_type(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);
  {
    try {
      result = (Ogre::VertexAnimationType)((Ogre::SubMesh const *)arg1)->getVertexAnimationType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.get_vertex_animation_includes_normals

  call-seq:
    get_vertex_animation_includes_normals -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_get_vertex_animation_includes_normals(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);
  {
    try {
      result = (bool)((Ogre::SubMesh const *)arg1)->getVertexAnimationIncludesNormals();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.generate_extremes

  call-seq:
    generate_extremes(size_t count)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_generate_extremes(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);
  {
    try {
      (arg1)->generateExtremes(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.is_build_edges_enabled

  call-seq:
    is_build_edges_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_is_build_edges_enabled(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);
  {
    try {
      result = (bool)((Ogre::SubMesh const *)arg1)->isBuildEdgesEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SubMesh.set_build_edges_enabled

  call-seq:
    set_build_edges_enabled(bool b)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SubMesh_set_build_edges_enabled(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);
  {
    try {
      (arg1)->setBuildEdgesEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::TagPoint < Ogre::Ogre::Bone

  Proxy of C++ Ogre::TagPoint class


*/
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;
  }
  


/*
  Document-method: Ogre::TagPoint.new

  call-seq:
    TagPoint.new(unsigned short handle, Skeleton creator)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::TagPoint *)new Ogre::TagPoint(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TagPoint(Ogre::TagPoint *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::TagPoint.get_parent_entity

  call-seq:
    get_parent_entity -> Entity

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint_get_parent_entity(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);
  {
    try {
      result = (Ogre::Entity *)((Ogre::TagPoint const *)arg1)->getParentEntity();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TagPoint.get_child_object

  call-seq:
    get_child_object -> MovableObject

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint_get_child_object(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);
  {
    try {
      result = (Ogre::MovableObject *)((Ogre::TagPoint const *)arg1)->getChildObject();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TagPoint.set_parent_entity

  call-seq:
    set_parent_entity(Entity pEntity)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint_set_parent_entity(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);
  {
    try {
      (arg1)->setParentEntity(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TagPoint.set_child_object

  call-seq:
    set_child_object(MovableObject pObject)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint_set_child_object(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);
  {
    try {
      (arg1)->setChildObject(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TagPoint.set_inherit_parent_entity_orientation

  call-seq:
    set_inherit_parent_entity_orientation(bool inherit)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint_set_inherit_parent_entity_orientation(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);
  {
    try {
      (arg1)->setInheritParentEntityOrientation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TagPoint.get_inherit_parent_entity_orientation

  call-seq:
    get_inherit_parent_entity_orientation -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint_get_inherit_parent_entity_orientation(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);
  {
    try {
      result = (bool)((Ogre::TagPoint const *)arg1)->getInheritParentEntityOrientation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TagPoint.set_inherit_parent_entity_scale

  call-seq:
    set_inherit_parent_entity_scale(bool inherit)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint_set_inherit_parent_entity_scale(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);
  {
    try {
      (arg1)->setInheritParentEntityScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TagPoint.get_inherit_parent_entity_scale

  call-seq:
    get_inherit_parent_entity_scale -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint_get_inherit_parent_entity_scale(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);
  {
    try {
      result = (bool)((Ogre::TagPoint const *)arg1)->getInheritParentEntityScale();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TagPoint.get_parent_entity_transform

  call-seq:
    get_parent_entity_transform -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint_get_parent_entity_transform(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::TagPoint const *)arg1)->getParentEntityTransform();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TagPoint._get_full_local_transform

  call-seq:
    _get_full_local_transform -> Matrix4

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint__get_full_local_transform(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);
  {
    try {
      result = (Ogre::Matrix4 *) &((Ogre::TagPoint const *)arg1)->_getFullLocalTransform();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TagPoint.need_update

  call-seq:
    need_update(bool forceParentUpdate=false)
    need_update

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint_need_update__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);
  {
    try {
      (arg1)->needUpdate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_need_update__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);
  {
    try {
      (arg1)->needUpdate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TagPoint_need_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__TagPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TagPoint_need_update__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_need_update__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TagPoint.need_update", 
    "    void TagPoint.need_update(bool forceParentUpdate)\n"
    "    void TagPoint.need_update()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TagPoint.update_from_parent_impl

  call-seq:
    update_from_parent_impl

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint_update_from_parent_impl(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);
  {
    try {
      ((Ogre::TagPoint const *)arg1)->updateFromParentImpl();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TagPoint.get_lights

  call-seq:
    get_lights -> LightList

An instance method.

*/
SWIGINTERN VALUE
_wrap_TagPoint_get_lights(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);
  {
    try {
      result = (Ogre::LightList *) &((Ogre::TagPoint const *)arg1)->getLights();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::TangentSpaceCalc

  Proxy of C++ Ogre::TangentSpaceCalc class


*/
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;
  }
  


/*
  Document-method: Ogre::TangentSpaceCalc.new

  call-seq:
    TangentSpaceCalc.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TangentSpaceCalc *)new Ogre::TangentSpaceCalc();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_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);
  {
    try {
      (arg1)->clear();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TangentSpaceCalc.set_vertex_data

  call-seq:
    set_vertex_data(VertexData v_in)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TangentSpaceCalc_set_vertex_data(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);
  {
    try {
      (arg1)->setVertexData(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TangentSpaceCalc.add_index_data

  call-seq:
    add_index_data(IndexData i_in, OperationType opType=OT_TRIANGLE_LIST)
    add_index_data(IndexData i_in)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TangentSpaceCalc_add_index_data__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);
  {
    try {
      (arg1)->addIndexData(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_add_index_data__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);
  {
    try {
      (arg1)->addIndexData(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TangentSpaceCalc_add_index_data(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_add_index_data__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_add_index_data__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TangentSpaceCalc.add_index_data", 
    "    void TangentSpaceCalc.add_index_data(Ogre::IndexData *i_in, Ogre::RenderOperation::OperationType opType)\n"
    "    void TangentSpaceCalc.add_index_data(Ogre::IndexData *i_in)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TangentSpaceCalc.set_store_parity_in_w

  call-seq:
    set_store_parity_in_w(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TangentSpaceCalc_set_store_parity_in_w(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);
  {
    try {
      (arg1)->setStoreParityInW(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TangentSpaceCalc.get_store_parity_in_w

  call-seq:
    get_store_parity_in_w -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TangentSpaceCalc_get_store_parity_in_w(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);
  {
    try {
      result = (bool)((Ogre::TangentSpaceCalc const *)arg1)->getStoreParityInW();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TangentSpaceCalc.set_split_mirrored

  call-seq:
    set_split_mirrored(bool split)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TangentSpaceCalc_set_split_mirrored(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);
  {
    try {
      (arg1)->setSplitMirrored(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TangentSpaceCalc.get_split_mirrored

  call-seq:
    get_split_mirrored -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TangentSpaceCalc_get_split_mirrored(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);
  {
    try {
      result = (bool)((Ogre::TangentSpaceCalc const *)arg1)->getSplitMirrored();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TangentSpaceCalc.set_split_rotated

  call-seq:
    set_split_rotated(bool split)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TangentSpaceCalc_set_split_rotated(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);
  {
    try {
      (arg1)->setSplitRotated(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TangentSpaceCalc.get_split_rotated

  call-seq:
    get_split_rotated -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TangentSpaceCalc_get_split_rotated(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);
  {
    try {
      result = (bool)((Ogre::TangentSpaceCalc const *)arg1)->getSplitRotated();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TangentSpaceCalc.build

  call-seq:
    build(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0, 
    unsigned short index=1) -> Result
    build(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0) -> Result
    build(VertexElementSemantic targetSemantic=VES_TANGENT) -> Result
    build -> Result

An instance method.

*/
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);
  {
    try {
      result = (arg1)->build(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = (arg1)->build(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->build(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->build();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-class: Ogre::UnifiedHighLevelGpuProgram < Ogre::Ogre::HighLevelGpuProgram

  Proxy of C++ Ogre::UnifiedHighLevelGpuProgram class


*/
swig_class SwigClassUnifiedHighLevelGpuProgram;


/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.new

  call-seq:
    UnifiedHighLevelGpuProgram.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual=false, 
    ManualResourceLoader loader=0)
    UnifiedHighLevelGpuProgram.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group, bool isManual=false)
    UnifiedHighLevelGpuProgram.new(ResourceManager creator, String name, ResourceHandle handle, 
    String group)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::UnifiedHighLevelGpuProgram *)new Ogre::UnifiedHighLevelGpuProgram(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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);
  {
    try {
      result = (Ogre::UnifiedHighLevelGpuProgram *)new Ogre::UnifiedHighLevelGpuProgram(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::UnifiedHighLevelGpuProgram *)new Ogre::UnifiedHighLevelGpuProgram(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.add_delegate_program

  call-seq:
    add_delegate_program(String name)

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_add_delegate_program(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;
  }
  {
    try {
      (arg1)->addDelegateProgram((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.clear_delegate_programs

  call-seq:
    clear_delegate_programs

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_clear_delegate_programs(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);
  {
    try {
      (arg1)->clearDelegatePrograms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram._get_delegate

  call-seq:
    _get_delegate -> HighLevelGpuProgramPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram__get_delegate(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);
  {
    try {
      result = (Ogre::HighLevelGpuProgramPtr *) &((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->_getDelegate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HighLevelGpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.get_language

  call-seq:
    get_language -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_get_language(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->getLanguage();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.create_parameters

  call-seq:
    create_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_create_parameters(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);
  {
    try {
      result = (arg1)->createParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram._get_binding_delegate

  call-seq:
    _get_binding_delegate -> GpuProgram

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram__get_binding_delegate(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);
  {
    try {
      result = (Ogre::GpuProgram *)(arg1)->_getBindingDelegate();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgram, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.is_supported

  call-seq:
    is_supported -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_is_supported(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isSupported();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.is_skeletal_animation_included

  call-seq:
    is_skeletal_animation_included -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_is_skeletal_animation_included(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isSkeletalAnimationIncluded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.is_morph_animation_included

  call-seq:
    is_morph_animation_included -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_is_morph_animation_included(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isMorphAnimationIncluded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.is_pose_animation_included

  call-seq:
    is_pose_animation_included -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_is_pose_animation_included(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isPoseAnimationIncluded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.is_vertex_texture_fetch_required

  call-seq:
    is_vertex_texture_fetch_required -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_is_vertex_texture_fetch_required(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isVertexTextureFetchRequired();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.get_default_parameters

  call-seq:
    get_default_parameters -> GpuProgramParametersSharedPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_get_default_parameters(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);
  {
    try {
      result = (arg1)->getDefaultParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.has_default_parameters

  call-seq:
    has_default_parameters -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_has_default_parameters(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->hasDefaultParameters();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.get_pass_surface_and_light_states

  call-seq:
    get_pass_surface_and_light_states -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_get_pass_surface_and_light_states(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->getPassSurfaceAndLightStates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.get_pass_fog_states

  call-seq:
    get_pass_fog_states -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_get_pass_fog_states(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->getPassFogStates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.get_pass_transform_states

  call-seq:
    get_pass_transform_states -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_get_pass_transform_states(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->getPassTransformStates();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.has_compile_error

  call-seq:
    has_compile_error -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_has_compile_error(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->hasCompileError();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.reset_compile_error

  call-seq:
    reset_compile_error

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_reset_compile_error(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);
  {
    try {
      (arg1)->resetCompileError();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.load

  call-seq:
    load(bool backgroundThread=false)
    load

An instance method.

*/
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);
  {
    try {
      (arg1)->load(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.reload

  call-seq:
    reload

An instance method.

*/
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);
  {
    try {
      (arg1)->reload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.is_reloadable

  call-seq:
    is_reloadable -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_is_reloadable(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isReloadable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.is_loaded

  call-seq:
    is_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_is_loaded(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.is_loading

  call-seq:
    is_loading -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_is_loading(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isLoading();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.get_loading_state

  call-seq:
    get_loading_state -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_get_loading_state(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);
  {
    try {
      result = (Ogre::Resource::LoadingState)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->getLoadingState();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.get_size

  call-seq:
    get_size -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_get_size(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);
  {
    try {
      result = ((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->getSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.touch

  call-seq:
    touch

An instance method.

*/
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);
  {
    try {
      (arg1)->touch();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.is_background_loaded

  call-seq:
    is_background_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_is_background_loaded(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);
  {
    try {
      result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isBackgroundLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.set_background_loaded

  call-seq:
    set_background_loaded(bool bl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_set_background_loaded(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);
  {
    try {
      (arg1)->setBackgroundLoaded(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.escalate_loading

  call-seq:
    escalate_loading

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_escalate_loading(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);
  {
    try {
      (arg1)->escalateLoading();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.add_listener

  call-seq:
    add_listener(Listener lis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_add_listener(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);
  {
    try {
      (arg1)->addListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UnifiedHighLevelGpuProgram.remove_listener

  call-seq:
    remove_listener(Listener lis)

An instance method.

*/
SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_remove_listener(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);
  {
    try {
      (arg1)->removeListener(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::WindowEventListener

  Proxy of C++ Ogre::WindowEventListener class


*/
swig_class SwigClassWindowEventListener;

SWIGINTERN void
free_Ogre_WindowEventListener(Ogre::WindowEventListener *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::WindowEventListener.window_moved

  call-seq:
    window_moved(RenderWindow rw)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WindowEventListener_window_moved(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);
  {
    try {
      (arg1)->windowMoved(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WindowEventListener.window_resized

  call-seq:
    window_resized(RenderWindow rw)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WindowEventListener_window_resized(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);
  {
    try {
      (arg1)->windowResized(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WindowEventListener.window_closing

  call-seq:
    window_closing(RenderWindow rw) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_WindowEventListener_window_closing(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);
  {
    try {
      result = (bool)(arg1)->windowClosing(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WindowEventListener.window_closed

  call-seq:
    window_closed(RenderWindow rw)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WindowEventListener_window_closed(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);
  {
    try {
      (arg1)->windowClosed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WindowEventListener.window_focus_change

  call-seq:
    window_focus_change(RenderWindow rw)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WindowEventListener_window_focus_change(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);
  {
    try {
      (arg1)->windowFocusChange(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


#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;
  }
  


/*
  Document-method: Ogre::WindowEventListener.new

  call-seq:
    WindowEventListener.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::WindowEventListener *)new Ogre::WindowEventListener();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::WindowEventUtilities

  Proxy of C++ Ogre::WindowEventUtilities class


*/
swig_class SwigClassWindowEventUtilities;


/*
  Document-method: Ogre::WindowEventUtilities.message_pump

  call-seq:
    message_pump

A class method.

*/
SWIGINTERN VALUE
_wrap_WindowEventUtilities_message_pump(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      Ogre::WindowEventUtilities::messagePump();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WindowEventUtilities.add_window_event_listener

  call-seq:
    add_window_event_listener(RenderWindow window, WindowEventListener listener)

A class method.

*/
SWIGINTERN VALUE
_wrap_WindowEventUtilities_add_window_event_listener(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);
  {
    try {
      Ogre::WindowEventUtilities::addWindowEventListener(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WindowEventUtilities.remove_window_event_listener

  call-seq:
    remove_window_event_listener(RenderWindow window, WindowEventListener listener)

A class method.

*/
SWIGINTERN VALUE
_wrap_WindowEventUtilities_remove_window_event_listener(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);
  {
    try {
      Ogre::WindowEventUtilities::removeWindowEventListener(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WindowEventUtilities._add_render_window

  call-seq:
    _add_render_window(RenderWindow window)

A class method.

*/
SWIGINTERN VALUE
_wrap_WindowEventUtilities__add_render_window(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);
  {
    try {
      Ogre::WindowEventUtilities::_addRenderWindow(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WindowEventUtilities._remove_render_window

  call-seq:
    _remove_render_window(RenderWindow window)

A class method.

*/
SWIGINTERN VALUE
_wrap_WindowEventUtilities__remove_render_window(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);
  {
    try {
      Ogre::WindowEventUtilities::_removeRenderWindow(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WindowEventUtilities._msListeners

  call-seq:
    _msListeners -> WindowEventListeners

Get value of attribute.

*/

/*
  Document-method: Ogre::WindowEventUtilities._msListeners=

  call-seq:
    _msListeners=(x) -> WindowEventListeners

Set new value for attribute.

*/

/*
  Document-method: Ogre::WindowEventUtilities.WindowEventUtilities__msListeners

  call-seq:
    WindowEventUtilities__msListeners -> WindowEventListeners

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::WindowEventUtilities.WindowEventUtilities__msListeners=

  call-seq:
    WindowEventUtilities__msListeners=(x) -> WindowEventListeners

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::WindowEventUtilities._msWindows

  call-seq:
    _msWindows -> Windows

Get value of attribute.

*/

/*
  Document-method: Ogre::WindowEventUtilities._msWindows=

  call-seq:
    _msWindows=(x) -> Windows

Set new value for attribute.

*/

/*
  Document-method: Ogre::WindowEventUtilities.WindowEventUtilities__msWindows

  call-seq:
    WindowEventUtilities__msWindows -> Windows

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::WindowEventUtilities.WindowEventUtilities__msWindows=

  call-seq:
    WindowEventUtilities__msWindows=(x) -> Windows

Set new value for attribute.

*/
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;
  }
  


/*
  Document-method: Ogre::WindowEventUtilities.new

  call-seq:
    WindowEventUtilities.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::WindowEventUtilities *)new Ogre::WindowEventUtilities();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_WindowEventUtilities(Ogre::WindowEventUtilities *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::WireBoundingBox < Ogre::Ogre::SimpleRenderable

  Proxy of C++ Ogre::WireBoundingBox class


*/
swig_class SwigClassWireBoundingBox;


/*
  Document-method: Ogre::WireBoundingBox.new

  call-seq:
    WireBoundingBox.new
    WireBoundingBox.new(String name)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::WireBoundingBox *)new Ogre::WireBoundingBox();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      result = (Ogre::WireBoundingBox *)new Ogre::WireBoundingBox((Ogre::String const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::WireBoundingBox.setup_bounding_box

  call-seq:
    setup_bounding_box(AxisAlignedBox aabb)

An instance method.

*/
SWIGINTERN VALUE
_wrap_WireBoundingBox_setup_bounding_box(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);
  {
    try {
      (arg1)->setupBoundingBox((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WireBoundingBox.get_squared_view_depth

  call-seq:
    get_squared_view_depth(Camera cam) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_WireBoundingBox_get_squared_view_depth(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);
  {
    try {
      result = (Ogre::Real)((Ogre::WireBoundingBox const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::WireBoundingBox.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_WireBoundingBox_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::WireBoundingBox const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::ZipArchive < Ogre::Ogre::Archive

  Proxy of C++ Ogre::ZipArchive class


*/
swig_class SwigClassZipArchive;


/*
  Document-method: Ogre::ZipArchive.new

  call-seq:
    ZipArchive.new(String name, String archType, zzip_plugin_io_handlers pluginIo=nil)
    ZipArchive.new(String name, String archType)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::ZipArchive *)new Ogre::ZipArchive((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
  }
  {
    try {
      result = (Ogre::ZipArchive *)new Ogre::ZipArchive((Ogre::String const &)*arg1,(Ogre::String const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::ZipArchive.is_case_sensitive

  call-seq:
    is_case_sensitive -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_ZipArchive_is_case_sensitive(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);
  {
    try {
      result = (bool)((Ogre::ZipArchive const *)arg1)->isCaseSensitive();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ZipArchive.load

  call-seq:
    load

An instance method.

*/
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);
  {
    try {
      (arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ZipArchive.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ZipArchive.open

  call-seq:
    open(String filename, bool readOnly=true) -> DataStreamPtr
    open(String filename) -> DataStreamPtr

An instance method.

*/
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);
  {
    try {
      result = ((Ogre::ZipArchive const *)arg1)->open((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
  }
  {
    try {
      result = ((Ogre::ZipArchive const *)arg1)->open((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ZipArchive.create

  call-seq:
    create(String filename) -> DataStreamPtr

An instance method.

*/
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;
  }
  {
    try {
      result = ((Ogre::ZipArchive const *)arg1)->create((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ZipArchive.remove

  call-seq:
    remove(String filename)

An instance method.

*/
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;
  }
  {
    try {
      ((Ogre::ZipArchive const *)arg1)->remove((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ZipArchive.list

  call-seq:
    list(bool recursive=true, bool dirs=false) -> StringVectorPtr
    list(bool recursive=true) -> StringVectorPtr
    list -> StringVectorPtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->list(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->list(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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);
  {
    try {
      result = (arg1)->list();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ZipArchive.list_file_info

  call-seq:
    list_file_info(bool recursive=true, bool dirs=false) -> FileInfoListPtr
    list_file_info(bool recursive=true) -> FileInfoListPtr
    list_file_info -> FileInfoListPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ZipArchive_list_file_info__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);
  {
    try {
      result = (arg1)->listFileInfo(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_list_file_info__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);
  {
    try {
      result = (arg1)->listFileInfo(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_list_file_info__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);
  {
    try {
      result = (arg1)->listFileInfo();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_list_file_info(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_file_info__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_file_info__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_file_info__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ZipArchive.list_file_info", 
    "    Ogre::FileInfoListPtr ZipArchive.list_file_info(bool recursive, bool dirs)\n"
    "    Ogre::FileInfoListPtr ZipArchive.list_file_info(bool recursive)\n"
    "    Ogre::FileInfoListPtr ZipArchive.list_file_info()\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);
  {
    try {
      result = (arg1)->find((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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);
  {
    try {
      result = (arg1)->find((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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;
  }
  {
    try {
      result = (arg1)->find((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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;
}



/*
  Document-method: Ogre::ZipArchive.find_file_info

  call-seq:
    find_file_info(String pattern, bool recursive=true, bool dirs=false) -> FileInfoListPtr
    find_file_info(String pattern, bool recursive=true) -> FileInfoListPtr
    find_file_info(String pattern) -> FileInfoListPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_ZipArchive_find_file_info__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);
  {
    try {
      result = ((Ogre::ZipArchive const *)arg1)->findFileInfo((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_find_file_info__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);
  {
    try {
      result = ((Ogre::ZipArchive const *)arg1)->findFileInfo((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_find_file_info__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;
  }
  {
    try {
      result = ((Ogre::ZipArchive const *)arg1)->findFileInfo((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_find_file_info(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_file_info__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_file_info__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_file_info__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ZipArchive.find_file_info", 
    "    Ogre::FileInfoListPtr ZipArchive.find_file_info(Ogre::String const &pattern, bool recursive, bool dirs)\n"
    "    Ogre::FileInfoListPtr ZipArchive.find_file_info(Ogre::String const &pattern, bool recursive)\n"
    "    Ogre::FileInfoListPtr ZipArchive.find_file_info(Ogre::String const &pattern)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ZipArchive.exists

  call-seq:
    exists(String filename) -> bool

An instance method.

*/
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;
  }
  {
    try {
      result = (bool)(arg1)->exists((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::ZipArchive.get_modified_time

  call-seq:
    get_modified_time(String filename) -> time_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_ZipArchive_get_modified_time(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;
  }
  {
    try {
      result = (arg1)->getModifiedTime((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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;
}



/*
  Document-class: Ogre::EmbeddedZipArchiveFactory

  Proxy of C++ Ogre::EmbeddedZipArchiveFactory class


*/
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;
  }
  


/*
  Document-method: Ogre::EmbeddedZipArchiveFactory.new

  call-seq:
    EmbeddedZipArchiveFactory.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::EmbeddedZipArchiveFactory *)new Ogre::EmbeddedZipArchiveFactory();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmbeddedZipArchiveFactory(Ogre::EmbeddedZipArchiveFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::EmbeddedZipArchiveFactory.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_EmbeddedZipArchiveFactory_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::EmbeddedZipArchiveFactory const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::EmbeddedZipArchiveFactory.create_instance

  call-seq:
    create_instance(String name) -> Archive

An instance method.

*/
SWIGINTERN VALUE
_wrap_EmbeddedZipArchiveFactory_create_instance(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;
  }
  {
    try {
      result = (Ogre::Archive *)(arg1)->createInstance((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Archive, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::EmbeddedZipArchiveFactory.add_embbedded_file

  call-seq:
    add_embbedded_file(String name, uint8 fileData, size_t fileSize, DecryptEmbeddedZipFileFunc decryptFunc)

A class method.

*/
SWIGINTERN VALUE
_wrap_EmbeddedZipArchiveFactory_add_embbedded_file(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] )); 
    }
  }
  {
    try {
      Ogre::EmbeddedZipArchiveFactory::addEmbbeddedFile((std::string const &)*arg1,(unsigned char const *)arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}



/*
  Document-method: Ogre::EmbeddedZipArchiveFactory.remove_embbedded_file

  call-seq:
    remove_embbedded_file(String name)

A class method.

*/
SWIGINTERN VALUE
_wrap_EmbeddedZipArchiveFactory_remove_embbedded_file(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;
  }
  {
    try {
      Ogre::EmbeddedZipArchiveFactory::removeEmbbeddedFile((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}



/*
  Document-class: Ogre::PageStrategyData

  Proxy of C++ Ogre::PageStrategyData class


*/
swig_class SwigClassPageStrategyData;

SWIGINTERN void
free_Ogre_PageStrategyData(Ogre::PageStrategyData *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PageStrategyData.load

  call-seq:
    load(StreamSerialiser stream) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)(arg1)->load(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageStrategyData.save

  call-seq:
    save(StreamSerialiser stream)

An instance method.

*/
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);
  {
    try {
      (arg1)->save(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PageStrategy

  Proxy of C++ Ogre::PageStrategy class


*/
swig_class SwigClassPageStrategy;

SWIGINTERN void
free_Ogre_PageStrategy(Ogre::PageStrategy *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PageStrategy.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageStrategy_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::PageStrategy const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageStrategy.get_manager

  call-seq:
    get_manager -> PageManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageStrategy_get_manager(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);
  {
    try {
      result = (Ogre::PageManager *)((Ogre::PageStrategy const *)arg1)->getManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageStrategy.frame_start

  call-seq:
    frame_start(Real timeSinceLastFrame, PagedWorldSection section)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageStrategy_frame_start(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);
  {
    try {
      (arg1)->frameStart(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageStrategy.frame_end

  call-seq:
    frame_end(Real timeElapsed, PagedWorldSection section)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageStrategy_frame_end(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);
  {
    try {
      (arg1)->frameEnd(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageStrategy.notify_camera

  call-seq:
    notify_camera(Camera cam, PagedWorldSection section)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageStrategy_notify_camera(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);
  {
    try {
      (arg1)->notifyCamera(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageStrategy.create_data

  call-seq:
    create_data -> PageStrategyData

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageStrategy_create_data(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);
  {
    try {
      result = (Ogre::PageStrategyData *)(arg1)->createData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageStrategyData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageStrategy.destroy_data

  call-seq:
    destroy_data(PageStrategyData d)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageStrategy_destroy_data(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);
  {
    try {
      (arg1)->destroyData(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageStrategy.update_debug_display

  call-seq:
    update_debug_display(Page p, SceneNode sn)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageStrategy_update_debug_display(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);
  {
    try {
      (arg1)->updateDebugDisplay(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageStrategy.get_page_id

  call-seq:
    get_page_id(Vector3 worldPos, PagedWorldSection section) -> PageID

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageStrategy_get_page_id(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);
  {
    try {
      result = (Ogre::PageID)(arg1)->getPageID((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Grid2DPageStrategyData < Ogre::Ogre::PageStrategyData

  Proxy of C++ Ogre::Grid2DPageStrategyData class


*/
swig_class SwigClassGrid2DPageStrategyData;


/*
  Document-method: Ogre::Grid2DPageStrategyData.CHUNK_ID

  call-seq:
    CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::Grid2DPageStrategyData.Grid2DPageStrategyData_CHUNK_ID

  call-seq:
    Grid2DPageStrategyData_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.CHUNK_VERSION

  call-seq:
    CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Grid2DPageStrategyData.Grid2DPageStrategyData_CHUNK_VERSION

  call-seq:
    Grid2DPageStrategyData_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
  }
  


/*
  Document-method: Ogre::Grid2DPageStrategyData.new

  call-seq:
    Grid2DPageStrategyData.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Grid2DPageStrategyData *)new Ogre::Grid2DPageStrategyData();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Grid2DPageStrategyData(Ogre::Grid2DPageStrategyData *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Grid2DPageStrategyData.set_mode

  call-seq:
    set_mode(Grid2DMode mode)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_set_mode(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);
  {
    try {
      (arg1)->setMode(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_mode

  call-seq:
    get_mode -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_mode(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);
  {
    try {
      result = (Ogre::Grid2DMode)((Ogre::Grid2DPageStrategyData const *)arg1)->getMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.set_origin

  call-seq:
    set_origin(Vector3 worldOrigin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_set_origin(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);
  {
    try {
      (arg1)->setOrigin((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_origin

  call-seq:
    get_origin(Vector3 worldOrigin) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_origin(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);
  {
    try {
      result = (Ogre::Vector3 *) &(arg1)->getOrigin((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.set_cell_size

  call-seq:
    set_cell_size(Real sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_set_cell_size(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);
  {
    try {
      (arg1)->setCellSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_cell_size

  call-seq:
    get_cell_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_cell_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Grid2DPageStrategyData const *)arg1)->getCellSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.set_load_radius

  call-seq:
    set_load_radius(Real sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_set_load_radius(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);
  {
    try {
      (arg1)->setLoadRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_load_radius

  call-seq:
    get_load_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_load_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Grid2DPageStrategyData const *)arg1)->getLoadRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.set_hold_radius

  call-seq:
    set_hold_radius(Real sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_set_hold_radius(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);
  {
    try {
      (arg1)->setHoldRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_hold_radius

  call-seq:
    get_hold_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_hold_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Grid2DPageStrategyData const *)arg1)->getHoldRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_load_radius_in_cells

  call-seq:
    get_load_radius_in_cells -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_load_radius_in_cells(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getLoadRadiusInCells();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_hold_radius_in_cells

  call-seq:
    get_hold_radius_in_cells -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_hold_radius_in_cells(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getHoldRadiusInCells();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.set_cell_range

  call-seq:
    set_cell_range(int32 minX, int32 minY, int32 maxX, int32 maxY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_set_cell_range(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);
  {
    try {
      (arg1)->setCellRange(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.set_cell_range_min_x

  call-seq:
    set_cell_range_min_x(int32 minX)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_set_cell_range_min_x(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);
  {
    try {
      (arg1)->setCellRangeMinX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.set_cell_range_min_y

  call-seq:
    set_cell_range_min_y(int32 minY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_set_cell_range_min_y(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);
  {
    try {
      (arg1)->setCellRangeMinY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.set_cell_range_max_x

  call-seq:
    set_cell_range_max_x(int32 maxX)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_set_cell_range_max_x(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);
  {
    try {
      (arg1)->setCellRangeMaxX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.set_cell_range_max_y

  call-seq:
    set_cell_range_max_y(int32 maxY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_set_cell_range_max_y(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);
  {
    try {
      (arg1)->setCellRangeMaxY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_cell_range_min_x

  call-seq:
    get_cell_range_min_x -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_cell_range_min_x(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);
  {
    try {
      result = (Ogre::int32)((Ogre::Grid2DPageStrategyData const *)arg1)->getCellRangeMinX();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_cell_range_min_y

  call-seq:
    get_cell_range_min_y -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_cell_range_min_y(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);
  {
    try {
      result = (Ogre::int32)((Ogre::Grid2DPageStrategyData const *)arg1)->getCellRangeMinY();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_cell_range_max_x

  call-seq:
    get_cell_range_max_x -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_cell_range_max_x(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);
  {
    try {
      result = (Ogre::int32)((Ogre::Grid2DPageStrategyData const *)arg1)->getCellRangeMaxX();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_cell_range_max_y

  call-seq:
    get_cell_range_max_y -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_cell_range_max_y(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);
  {
    try {
      result = (Ogre::int32)((Ogre::Grid2DPageStrategyData const *)arg1)->getCellRangeMaxY();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.load

  call-seq:
    load(StreamSerialiser stream) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)(arg1)->load(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.save

  call-seq:
    save(StreamSerialiser stream)

An instance method.

*/
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);
  {
    try {
      (arg1)->save(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.convert_world_to_grid_space

  call-seq:
    convert_world_to_grid_space(Vector3 world, Vector2 grid)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_convert_world_to_grid_space(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);
  {
    try {
      (arg1)->convertWorldToGridSpace((Ogre::Vector3 const &)*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.convert_grid_to_world_space

  call-seq:
    convert_grid_to_world_space(Vector2 grid, Vector3 world)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_convert_grid_to_world_space(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);
  {
    try {
      (arg1)->convertGridToWorldSpace((Ogre::Vector2 const &)*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_mid_point_grid_space

  call-seq:
    get_mid_point_grid_space(int32 x, int32 y, Vector2 mid)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_mid_point_grid_space(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);
  {
    try {
      (arg1)->getMidPointGridSpace(arg2,arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_bottom_left_grid_space

  call-seq:
    get_bottom_left_grid_space(int32 x, int32 y, Vector2 bl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_bottom_left_grid_space(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);
  {
    try {
      (arg1)->getBottomLeftGridSpace(arg2,arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.get_corners_grid_space

  call-seq:
    get_corners_grid_space(int32 x, int32 y, Vector2 pFourPoints)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_get_corners_grid_space(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);
  {
    try {
      (arg1)->getCornersGridSpace(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.determine_grid_location

  call-seq:
    determine_grid_location(Vector2 gridpos, int32 x, int32 y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_determine_grid_location(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);
  {
    try {
      (arg1)->determineGridLocation((Ogre::Vector2 const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.calculate_page_id

  call-seq:
    calculate_page_id(int32 x, int32 y) -> PageID

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_calculate_page_id(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);
  {
    try {
      result = (Ogre::PageID)(arg1)->calculatePageID(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategyData.calculate_cell

  call-seq:
    calculate_cell(PageID inPageID, int32 x, int32 y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_calculate_cell(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);
  {
    try {
      (arg1)->calculateCell(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Grid2DPageStrategy < Ogre::Ogre::PageStrategy

  Proxy of C++ Ogre::Grid2DPageStrategy class


*/
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;
  }
  


/*
  Document-method: Ogre::Grid2DPageStrategy.new

  call-seq:
    Grid2DPageStrategy.new(PageManager manager)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Grid2DPageStrategy *)new Ogre::Grid2DPageStrategy(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Grid2DPageStrategy(Ogre::Grid2DPageStrategy *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Grid2DPageStrategy.notify_camera

  call-seq:
    notify_camera(Camera cam, PagedWorldSection section)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategy_notify_camera(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);
  {
    try {
      (arg1)->notifyCamera(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategy.create_data

  call-seq:
    create_data -> PageStrategyData

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategy_create_data(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);
  {
    try {
      result = (Ogre::PageStrategyData *)(arg1)->createData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageStrategyData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategy.destroy_data

  call-seq:
    destroy_data(PageStrategyData d)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategy_destroy_data(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);
  {
    try {
      (arg1)->destroyData(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategy.update_debug_display

  call-seq:
    update_debug_display(Page p, SceneNode sn)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategy_update_debug_display(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);
  {
    try {
      (arg1)->updateDebugDisplay(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid2DPageStrategy.get_page_id

  call-seq:
    get_page_id(Vector3 worldPos, PagedWorldSection section) -> PageID

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid2DPageStrategy_get_page_id(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);
  {
    try {
      result = (Ogre::PageID)(arg1)->getPageID((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Grid3DPageStrategyData < Ogre::Ogre::PageStrategyData

  Proxy of C++ Ogre::Grid3DPageStrategyData class


*/
swig_class SwigClassGrid3DPageStrategyData;


/*
  Document-method: Ogre::Grid3DPageStrategyData.CHUNK_ID

  call-seq:
    CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::Grid3DPageStrategyData.Grid3DPageStrategyData_CHUNK_ID

  call-seq:
    Grid3DPageStrategyData_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.CHUNK_VERSION

  call-seq:
    CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Grid3DPageStrategyData.Grid3DPageStrategyData_CHUNK_VERSION

  call-seq:
    Grid3DPageStrategyData_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
  }
  


/*
  Document-method: Ogre::Grid3DPageStrategyData.new

  call-seq:
    Grid3DPageStrategyData.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::Grid3DPageStrategyData *)new Ogre::Grid3DPageStrategyData();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Grid3DPageStrategyData(Ogre::Grid3DPageStrategyData *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Grid3DPageStrategyData.set_origin

  call-seq:
    set_origin(Vector3 worldOrigin)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_set_origin(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);
  {
    try {
      (arg1)->setOrigin((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_origin

  call-seq:
    get_origin(Vector3 worldOrigin) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_origin(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);
  {
    try {
      result = (Ogre::Vector3 *) &(arg1)->getOrigin((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.set_cell_size

  call-seq:
    set_cell_size(Vector3 sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_set_cell_size(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);
  {
    try {
      (arg1)->setCellSize((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_cell_size

  call-seq:
    get_cell_size -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_cell_size(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);
  {
    try {
      result = ((Ogre::Grid3DPageStrategyData const *)arg1)->getCellSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.set_load_radius

  call-seq:
    set_load_radius(Real sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_set_load_radius(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);
  {
    try {
      (arg1)->setLoadRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_load_radius

  call-seq:
    get_load_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_load_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Grid3DPageStrategyData const *)arg1)->getLoadRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.set_hold_radius

  call-seq:
    set_hold_radius(Real sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_set_hold_radius(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);
  {
    try {
      (arg1)->setHoldRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_hold_radius

  call-seq:
    get_hold_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_hold_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Grid3DPageStrategyData const *)arg1)->getHoldRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.set_cell_range

  call-seq:
    set_cell_range(int32 minX, int32 minY, int32 minZ, int32 maxX, int32 maxY, 
    int32 maxZ)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_set_cell_range(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);
  {
    try {
      (arg1)->setCellRange(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.set_cell_range_min_x

  call-seq:
    set_cell_range_min_x(int32 minX)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_set_cell_range_min_x(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);
  {
    try {
      (arg1)->setCellRangeMinX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.set_cell_range_min_y

  call-seq:
    set_cell_range_min_y(int32 minY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_set_cell_range_min_y(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);
  {
    try {
      (arg1)->setCellRangeMinY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.set_cell_range_min_z

  call-seq:
    set_cell_range_min_z(int32 minZ)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_set_cell_range_min_z(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);
  {
    try {
      (arg1)->setCellRangeMinZ(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.set_cell_range_max_x

  call-seq:
    set_cell_range_max_x(int32 maxX)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_set_cell_range_max_x(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);
  {
    try {
      (arg1)->setCellRangeMaxX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.set_cell_range_max_y

  call-seq:
    set_cell_range_max_y(int32 maxY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_set_cell_range_max_y(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);
  {
    try {
      (arg1)->setCellRangeMaxY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.set_cell_range_max_z

  call-seq:
    set_cell_range_max_z(int32 maxZ)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_set_cell_range_max_z(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);
  {
    try {
      (arg1)->setCellRangeMaxZ(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_cell_range_min_x

  call-seq:
    get_cell_range_min_x -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_cell_range_min_x(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);
  {
    try {
      result = (Ogre::int32)((Ogre::Grid3DPageStrategyData const *)arg1)->getCellRangeMinX();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_cell_range_min_y

  call-seq:
    get_cell_range_min_y -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_cell_range_min_y(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);
  {
    try {
      result = (Ogre::int32)((Ogre::Grid3DPageStrategyData const *)arg1)->getCellRangeMinY();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_cell_range_min_z

  call-seq:
    get_cell_range_min_z -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_cell_range_min_z(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);
  {
    try {
      result = (Ogre::int32)((Ogre::Grid3DPageStrategyData const *)arg1)->getCellRangeMinZ();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_cell_range_max_x

  call-seq:
    get_cell_range_max_x -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_cell_range_max_x(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);
  {
    try {
      result = (Ogre::int32)((Ogre::Grid3DPageStrategyData const *)arg1)->getCellRangeMaxX();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_cell_range_max_y

  call-seq:
    get_cell_range_max_y -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_cell_range_max_y(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);
  {
    try {
      result = (Ogre::int32)((Ogre::Grid3DPageStrategyData const *)arg1)->getCellRangeMaxY();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_cell_range_max_z

  call-seq:
    get_cell_range_max_z -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_cell_range_max_z(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);
  {
    try {
      result = (Ogre::int32)((Ogre::Grid3DPageStrategyData const *)arg1)->getCellRangeMaxZ();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.load

  call-seq:
    load(StreamSerialiser stream) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)(arg1)->load(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.save

  call-seq:
    save(StreamSerialiser stream)

An instance method.

*/
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);
  {
    try {
      (arg1)->save(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_mid_point_grid_space

  call-seq:
    get_mid_point_grid_space(int32 x, int32 y, int32 z, Vector3 mid)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_mid_point_grid_space(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);
  {
    try {
      (arg1)->getMidPointGridSpace(arg2,arg3,arg4,*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_bottom_left_grid_space

  call-seq:
    get_bottom_left_grid_space(int32 x, int32 y, int z, Vector3 bl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_bottom_left_grid_space(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);
  {
    try {
      (arg1)->getBottomLeftGridSpace(arg2,arg3,arg4,*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.get_corners_grid_space

  call-seq:
    get_corners_grid_space(int32 x, int32 y, int32 z, Vector3 pEightPoints)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_get_corners_grid_space(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);
  {
    try {
      (arg1)->getCornersGridSpace(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.determine_grid_location

  call-seq:
    determine_grid_location(Vector3 gridpos, int32 x, int32 y, int32 z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_determine_grid_location(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);
  {
    try {
      (arg1)->determineGridLocation((Ogre::Vector3 const &)*arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.calculate_page_id

  call-seq:
    calculate_page_id(int32 x, int32 y, int32 z) -> PageID

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_calculate_page_id(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);
  {
    try {
      result = (Ogre::PageID)(arg1)->calculatePageID(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategyData.calculate_cell

  call-seq:
    calculate_cell(PageID inPageID, int32 x, int32 y, int32 z)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_calculate_cell(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);
  {
    try {
      (arg1)->calculateCell(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Grid3DPageStrategy < Ogre::Ogre::PageStrategy

  Proxy of C++ Ogre::Grid3DPageStrategy class


*/
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;
  }
  


/*
  Document-method: Ogre::Grid3DPageStrategy.new

  call-seq:
    Grid3DPageStrategy.new(PageManager manager)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Grid3DPageStrategy *)new Ogre::Grid3DPageStrategy(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Grid3DPageStrategy(Ogre::Grid3DPageStrategy *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Grid3DPageStrategy.notify_camera

  call-seq:
    notify_camera(Camera cam, PagedWorldSection section)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategy_notify_camera(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);
  {
    try {
      (arg1)->notifyCamera(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategy.create_data

  call-seq:
    create_data -> PageStrategyData

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategy_create_data(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);
  {
    try {
      result = (Ogre::PageStrategyData *)(arg1)->createData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageStrategyData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategy.destroy_data

  call-seq:
    destroy_data(PageStrategyData d)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategy_destroy_data(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);
  {
    try {
      (arg1)->destroyData(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategy.update_debug_display

  call-seq:
    update_debug_display(Page p, SceneNode sn)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategy_update_debug_display(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);
  {
    try {
      (arg1)->updateDebugDisplay(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Grid3DPageStrategy.get_page_id

  call-seq:
    get_page_id(Vector3 worldPos, PagedWorldSection section) -> PageID

An instance method.

*/
SWIGINTERN VALUE
_wrap_Grid3DPageStrategy_get_page_id(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);
  {
    try {
      result = (Ogre::PageID)(arg1)->getPageID((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Page

  Proxy of C++ Ogre::Page class


*/
swig_class SwigClassPage;


/*
  Document-method: Ogre::Page.CHUNK_ID

  call-seq:
    CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::Page.Page_CHUNK_ID

  call-seq:
    Page_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Page.CHUNK_VERSION

  call-seq:
    CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Page.Page_CHUNK_VERSION

  call-seq:
    Page_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Page.CHUNK_CONTENTCOLLECTION_DECLARATION_ID

  call-seq:
    CHUNK_CONTENTCOLLECTION_DECLARATION_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::Page.Page_CHUNK_CONTENTCOLLECTION_DECLARATION_ID

  call-seq:
    Page_CHUNK_CONTENTCOLLECTION_DECLARATION_ID -> uint32

Get value of attribute.

*/
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;
  }
  


/*
  Document-method: Ogre::Page.new

  call-seq:
    Page.new(PageID pageID, PagedWorldSection parent)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Page *)new Ogre::Page(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Page(Ogre::Page *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Page.get_manager

  call-seq:
    get_manager -> PageManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_get_manager(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);
  {
    try {
      result = (Ogre::PageManager *)((Ogre::Page const *)arg1)->getManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.get_scene_manager

  call-seq:
    get_scene_manager -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_get_scene_manager(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);
  {
    try {
      result = (Ogre::SceneManager *)((Ogre::Page const *)arg1)->getSceneManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.is_deferred_process_in_progress

  call-seq:
    is_deferred_process_in_progress -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_is_deferred_process_in_progress(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);
  {
    try {
      result = (bool)((Ogre::Page const *)arg1)->isDeferredProcessInProgress();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.get_id

  call-seq:
    get_id -> PageID

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_get_id(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);
  {
    try {
      result = (Ogre::PageID)((Ogre::Page const *)arg1)->getID();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.get_parent_section

  call-seq:
    get_parent_section -> PagedWorldSection

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_get_parent_section(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);
  {
    try {
      result = (Ogre::PagedWorldSection *)((Ogre::Page const *)arg1)->getParentSection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.get_frame_last_held

  call-seq:
    get_frame_last_held -> unsigned long

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_get_frame_last_held(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);
  {
    try {
      result = (unsigned long)(arg1)->getFrameLastHeld();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.touch

  call-seq:
    touch

An instance method.

*/
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);
  {
    try {
      (arg1)->touch();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.load

  call-seq:
    load(bool synchronous)

An instance method.

*/
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);
  {
    try {
      (arg1)->load(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.is_held

  call-seq:
    is_held -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_is_held(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);
  {
    try {
      result = (bool)((Ogre::Page const *)arg1)->isHeld();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.save

  call-seq:
    save
    save(String filename)
    save(StreamSerialiser stream)

An instance method.

*/
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);
  {
    try {
      (arg1)->save();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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;
  }
  {
    try {
      (arg1)->save((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->save(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Page.frame_start

  call-seq:
    frame_start(Real timeSinceLastFrame)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_frame_start(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);
  {
    try {
      (arg1)->frameStart(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.frame_end

  call-seq:
    frame_end(Real timeElapsed)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_frame_end(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);
  {
    try {
      (arg1)->frameEnd(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.notify_camera

  call-seq:
    notify_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_notify_camera(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);
  {
    try {
      (arg1)->notifyCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.create_content_collection

  call-seq:
    create_content_collection(String typeName) -> PageContentCollection

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_create_content_collection(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;
  }
  {
    try {
      result = (Ogre::PageContentCollection *)(arg1)->createContentCollection((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Page.destroy_content_collection

  call-seq:
    destroy_content_collection(PageContentCollection coll)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_destroy_content_collection(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);
  {
    try {
      (arg1)->destroyContentCollection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.destroy_all_content_collections

  call-seq:
    destroy_all_content_collections

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_destroy_all_content_collections(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);
  {
    try {
      (arg1)->destroyAllContentCollections();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.get_content_collection_count

  call-seq:
    get_content_collection_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_get_content_collection_count(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);
  {
    try {
      result = ((Ogre::Page const *)arg1)->getContentCollectionCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.get_content_collection

  call-seq:
    get_content_collection(size_t index) -> PageContentCollection

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_get_content_collection(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);
  {
    try {
      result = (Ogre::PageContentCollection *)(arg1)->getContentCollection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.get_content_collection_list

  call-seq:
    get_content_collection_list -> ContentCollectionList

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_get_content_collection_list(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);
  {
    try {
      result = (Ogre::Page::ContentCollectionList *) &((Ogre::Page const *)arg1)->getContentCollectionList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__PageContentCollection_p_Ogre__STLAllocatorT_Ogre__PageContentCollection_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.can_handle_request

  call-seq:
    can_handle_request(Request req, WorkQueue srcQ) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_can_handle_request(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);
  {
    try {
      result = (bool)(arg1)->canHandleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.handle_request

  call-seq:
    handle_request(Request req, WorkQueue srcQ) -> Response

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_handle_request(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);
  {
    try {
      result = (Ogre::WorkQueue::Response *)(arg1)->handleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.can_handle_response

  call-seq:
    can_handle_response(Response res, WorkQueue srcQ) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_can_handle_response(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);
  {
    try {
      result = (bool)(arg1)->canHandleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.handle_response

  call-seq:
    handle_response(Response res, WorkQueue srcQ)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_handle_response(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);
  {
    try {
      (arg1)->handleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page._notify_modified

  call-seq:
    _notify_modified

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page__notify_modified(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);
  {
    try {
      (arg1)->_notifyModified();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.is_modified

  call-seq:
    is_modified -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Page_is_modified(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);
  {
    try {
      result = (bool)((Ogre::Page const *)arg1)->isModified();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Page.WORKQUEUE_PREPARE_REQUEST

  call-seq:
    WORKQUEUE_PREPARE_REQUEST -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Page.Page_WORKQUEUE_PREPARE_REQUEST

  call-seq:
    Page_WORKQUEUE_PREPARE_REQUEST -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Page.WORKQUEUE_CHANGECOLLECTION_REQUEST

  call-seq:
    WORKQUEUE_CHANGECOLLECTION_REQUEST -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Page.Page_WORKQUEUE_CHANGECOLLECTION_REQUEST

  call-seq:
    Page_WORKQUEUE_CHANGECOLLECTION_REQUEST -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-class: Ogre::PageContent

  Proxy of C++ Ogre::PageContent class


*/
swig_class SwigClassPageContent;

SWIGINTERN void
free_Ogre_PageContent(Ogre::PageContent *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PageContent.get_manager

  call-seq:
    get_manager -> PageManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContent_get_manager(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);
  {
    try {
      result = (Ogre::PageManager *)((Ogre::PageContent const *)arg1)->getManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContent.get_scene_manager

  call-seq:
    get_scene_manager -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContent_get_scene_manager(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);
  {
    try {
      result = (Ogre::SceneManager *)((Ogre::PageContent const *)arg1)->getSceneManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContent._notify_attached

  call-seq:
    _notify_attached(PageContentCollection parent)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContent__notify_attached(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);
  {
    try {
      (arg1)->_notifyAttached(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContent.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContent_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::PageContent const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContent.save

  call-seq:
    save(StreamSerialiser stream)

An instance method.

*/
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);
  {
    try {
      (arg1)->save(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContent.frame_start

  call-seq:
    frame_start(Real timeSinceLastFrame)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContent_frame_start(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);
  {
    try {
      (arg1)->frameStart(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContent.frame_end

  call-seq:
    frame_end(Real timeElapsed)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContent_frame_end(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);
  {
    try {
      (arg1)->frameEnd(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContent.notify_camera

  call-seq:
    notify_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContent_notify_camera(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);
  {
    try {
      (arg1)->notifyCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContent.prepare

  call-seq:
    prepare(StreamSerialiser ser) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)(arg1)->prepare(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContent.load

  call-seq:
    load

An instance method.

*/
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);
  {
    try {
      (arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContent.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContent.unprepare

  call-seq:
    unprepare

An instance method.

*/
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);
  {
    try {
      (arg1)->unprepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PageContentCollection

  Proxy of C++ Ogre::PageContentCollection class


*/
swig_class SwigClassPageContentCollection;


/*
  Document-method: Ogre::PageContentCollection.CHUNK_ID

  call-seq:
    CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::PageContentCollection.PageContentCollection_CHUNK_ID

  call-seq:
    PageContentCollection_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::PageContentCollection.CHUNK_VERSION

  call-seq:
    CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::PageContentCollection.PageContentCollection_CHUNK_VERSION

  call-seq:
    PageContentCollection_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
}


/*
  Document-method: Ogre::PageContentCollection.get_manager

  call-seq:
    get_manager -> PageManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentCollection_get_manager(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);
  {
    try {
      result = (Ogre::PageManager *)((Ogre::PageContentCollection const *)arg1)->getManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollection.get_parent_page

  call-seq:
    get_parent_page -> Page

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentCollection_get_parent_page(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);
  {
    try {
      result = (Ogre::Page *)((Ogre::PageContentCollection const *)arg1)->getParentPage();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Page, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollection.get_scene_manager

  call-seq:
    get_scene_manager -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentCollection_get_scene_manager(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);
  {
    try {
      result = (Ogre::SceneManager *)((Ogre::PageContentCollection const *)arg1)->getSceneManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollection.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentCollection_get_type(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::PageContentCollection const *)arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollection._notify_attached

  call-seq:
    _notify_attached(Page parent)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentCollection__notify_attached(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);
  {
    try {
      (arg1)->_notifyAttached(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollection.save

  call-seq:
    save(StreamSerialiser stream)

An instance method.

*/
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);
  {
    try {
      (arg1)->save(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollection.frame_start

  call-seq:
    frame_start(Real timeSinceLastFrame)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentCollection_frame_start(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);
  {
    try {
      (arg1)->frameStart(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollection.frame_end

  call-seq:
    frame_end(Real timeElapsed)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentCollection_frame_end(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);
  {
    try {
      (arg1)->frameEnd(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollection.notify_camera

  call-seq:
    notify_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentCollection_notify_camera(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);
  {
    try {
      (arg1)->notifyCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollection.prepare

  call-seq:
    prepare(StreamSerialiser ser) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)(arg1)->prepare(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollection.load

  call-seq:
    load

An instance method.

*/
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);
  {
    try {
      (arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollection.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollection.unprepare

  call-seq:
    unprepare

An instance method.

*/
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);
  {
    try {
      (arg1)->unprepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PageContentCollectionFactory

  Proxy of C++ Ogre::PageContentCollectionFactory class


*/
swig_class SwigClassPageContentCollectionFactory;

SWIGINTERN void
free_Ogre_PageContentCollectionFactory(Ogre::PageContentCollectionFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PageContentCollectionFactory.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentCollectionFactory_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::PageContentCollectionFactory const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollectionFactory.create_instance

  call-seq:
    create_instance -> PageContentCollection

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentCollectionFactory_create_instance(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);
  {
    try {
      result = (Ogre::PageContentCollection *)(arg1)->createInstance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentCollectionFactory.destroy_instance

  call-seq:
    destroy_instance(PageContentCollection ?)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentCollectionFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PageContentFactory

  Proxy of C++ Ogre::PageContentFactory class


*/
swig_class SwigClassPageContentFactory;

SWIGINTERN void
free_Ogre_PageContentFactory(Ogre::PageContentFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PageContentFactory.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentFactory_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::PageContentFactory const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentFactory.create_instance

  call-seq:
    create_instance -> PageContent

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentFactory_create_instance(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);
  {
    try {
      result = (Ogre::PageContent *)(arg1)->createInstance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContent, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageContentFactory.destroy_instance

  call-seq:
    destroy_instance(PageContent ?)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageContentFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PageProvider

  Proxy of C++ Ogre::PageProvider class


*/
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;
  }
  


/*
  Document-method: Ogre::PageProvider.new

  call-seq:
    PageProvider.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PageProvider *)new Ogre::PageProvider();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PageProvider(Ogre::PageProvider *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PageProvider.prepare_procedural_page

  call-seq:
    prepare_procedural_page(Page page, PagedWorldSection section) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageProvider_prepare_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->prepareProceduralPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageProvider.load_procedural_page

  call-seq:
    load_procedural_page(Page page, PagedWorldSection section) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageProvider_load_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->loadProceduralPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageProvider.unload_procedural_page

  call-seq:
    unload_procedural_page(Page page, PagedWorldSection section) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageProvider_unload_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->unloadProceduralPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageProvider.unprepare_procedural_page

  call-seq:
    unprepare_procedural_page(Page page, PagedWorldSection section) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageProvider_unprepare_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->unprepareProceduralPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageProvider.read_world_stream

  call-seq:
    read_world_stream(String filename) -> StreamSerialiser

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageProvider_read_world_stream(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;
  }
  {
    try {
      result = (Ogre::StreamSerialiser *)(arg1)->readWorldStream((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PageProvider.write_world_stream

  call-seq:
    write_world_stream(String filename) -> StreamSerialiser

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageProvider_write_world_stream(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;
  }
  {
    try {
      result = (Ogre::StreamSerialiser *)(arg1)->writeWorldStream((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PageProvider.read_page_stream

  call-seq:
    read_page_stream(PageID pageID, PagedWorldSection section) -> StreamSerialiser

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageProvider_read_page_stream(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);
  {
    try {
      result = (Ogre::StreamSerialiser *)(arg1)->readPageStream(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageProvider.write_page_stream

  call-seq:
    write_page_stream(PageID pageID, PagedWorldSection section) -> StreamSerialiser

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageProvider_write_page_stream(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);
  {
    try {
      result = (Ogre::StreamSerialiser *)(arg1)->writePageStream(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PageManager

  Proxy of C++ Ogre::PageManager class


*/
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;
  }
  


/*
  Document-method: Ogre::PageManager.new

  call-seq:
    PageManager.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::PageManager *)new Ogre::PageManager();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PageManager(Ogre::PageManager *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PageManager.create_world

  call-seq:
    create_world(String name=BLANK) -> PagedWorld
    create_world -> PagedWorld

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_create_world__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;
  }
  {
    try {
      result = (Ogre::PagedWorld *)(arg1)->createWorld((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_world__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);
  {
    try {
      result = (Ogre::PagedWorld *)(arg1)->createWorld();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PageManager_create_world(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_create_world__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_create_world__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PageManager.create_world", 
    "    Ogre::PagedWorld * PageManager.create_world(Ogre::String const &name)\n"
    "    Ogre::PagedWorld * PageManager.create_world()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.destroy_world

  call-seq:
    destroy_world(String name)
    destroy_world(PagedWorld world)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_destroy_world__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;
  }
  {
    try {
      (arg1)->destroyWorld((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_destroy_world__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);
  {
    try {
      (arg1)->destroyWorld(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PageManager_destroy_world(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_destroy_world__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_destroy_world__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PageManager.destroy_world", 
    "    void PageManager.destroy_world(Ogre::String const &name)\n"
    "    void PageManager.destroy_world(Ogre::PagedWorld *world)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.load_world

  call-seq:
    load_world(String filename, String name=BLANK) -> PagedWorld
    load_world(String filename) -> PagedWorld
    load_world(DataStreamPtr stream, String name=BLANK) -> PagedWorld
    load_world(DataStreamPtr stream) -> PagedWorld

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_load_world__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;
  }
  {
    try {
      result = (Ogre::PagedWorld *)(arg1)->loadWorld((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_load_world__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;
  }
  {
    try {
      result = (Ogre::PagedWorld *)(arg1)->loadWorld((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_load_world__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;
  }
  {
    try {
      result = (Ogre::PagedWorld *)(arg1)->loadWorld((Ogre::DataStreamPtr const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_load_world__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);
  {
    try {
      result = (Ogre::PagedWorld *)(arg1)->loadWorld((Ogre::DataStreamPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PageManager_load_world(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_load_world__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_load_world__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_load_world__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_load_world__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "PageManager.load_world", 
    "    Ogre::PagedWorld * PageManager.load_world(Ogre::String const &filename, Ogre::String const &name)\n"
    "    Ogre::PagedWorld * PageManager.load_world(Ogre::String const &filename)\n"
    "    Ogre::PagedWorld * PageManager.load_world(Ogre::DataStreamPtr const &stream, Ogre::String const &name)\n"
    "    Ogre::PagedWorld * PageManager.load_world(Ogre::DataStreamPtr const &stream)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.save_world

  call-seq:
    save_world(PagedWorld world, String filename)
    save_world(PagedWorld world, DataStreamPtr stream)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_save_world__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;
  }
  {
    try {
      (arg1)->saveWorld(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_save_world__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);
  {
    try {
      (arg1)->saveWorld(arg2,(Ogre::DataStreamPtr const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PageManager_save_world(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_save_world__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_save_world__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "PageManager.save_world", 
    "    void PageManager.save_world(Ogre::PagedWorld *world, Ogre::String const &filename)\n"
    "    void PageManager.save_world(Ogre::PagedWorld *world, Ogre::DataStreamPtr const &stream)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_world

  call-seq:
    get_world(String name) -> PagedWorld

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_world(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;
  }
  {
    try {
      result = (Ogre::PagedWorld *)(arg1)->getWorld((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_worlds

  call-seq:
    get_worlds -> WorldMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_worlds(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);
  {
    try {
      result = (Ogre::PageManager::WorldMap *) &((Ogre::PageManager const *)arg1)->getWorlds();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::PageManager.add_strategy

  call-seq:
    add_strategy(PageStrategy strategy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_add_strategy(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);
  {
    try {
      (arg1)->addStrategy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.remove_strategy

  call-seq:
    remove_strategy(PageStrategy strategy)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_remove_strategy(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);
  {
    try {
      (arg1)->removeStrategy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_strategy

  call-seq:
    get_strategy(String name) -> PageStrategy

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_strategy(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;
  }
  {
    try {
      result = (Ogre::PageStrategy *)(arg1)->getStrategy((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageStrategy, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_strategies

  call-seq:
    get_strategies -> StrategyMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_strategies(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);
  {
    try {
      result = (Ogre::PageManager::StrategyMap *) &((Ogre::PageManager const *)arg1)->getStrategies();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::PageManager.add_content_collection_factory

  call-seq:
    add_content_collection_factory(PageContentCollectionFactory f)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_add_content_collection_factory(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);
  {
    try {
      (arg1)->addContentCollectionFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.remove_content_collection_factory

  call-seq:
    remove_content_collection_factory(PageContentCollectionFactory f)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_remove_content_collection_factory(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);
  {
    try {
      (arg1)->removeContentCollectionFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_content_collection_factory

  call-seq:
    get_content_collection_factory(String name) -> PageContentCollectionFactory

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_content_collection_factory(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;
  }
  {
    try {
      result = (Ogre::PageContentCollectionFactory *)(arg1)->getContentCollectionFactory((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentCollectionFactory, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.create_content_collection

  call-seq:
    create_content_collection(String typeName) -> PageContentCollection

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_create_content_collection(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;
  }
  {
    try {
      result = (Ogre::PageContentCollection *)(arg1)->createContentCollection((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.destroy_content_collection

  call-seq:
    destroy_content_collection(PageContentCollection coll)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_destroy_content_collection(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);
  {
    try {
      (arg1)->destroyContentCollection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_content_collection_factories

  call-seq:
    get_content_collection_factories -> ContentCollectionFactoryMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_content_collection_factories(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);
  {
    try {
      result = (Ogre::PageManager::ContentCollectionFactoryMap *) &((Ogre::PageManager const *)arg1)->getContentCollectionFactories();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::PageManager.add_content_factory

  call-seq:
    add_content_factory(PageContentFactory f)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_add_content_factory(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);
  {
    try {
      (arg1)->addContentFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.remove_content_factory

  call-seq:
    remove_content_factory(PageContentFactory f)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_remove_content_factory(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);
  {
    try {
      (arg1)->removeContentFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_content_factory

  call-seq:
    get_content_factory(String name) -> PageContentFactory

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_content_factory(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;
  }
  {
    try {
      result = (Ogre::PageContentFactory *)(arg1)->getContentFactory((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentFactory, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_content_factories

  call-seq:
    get_content_factories -> ContentFactoryMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_content_factories(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);
  {
    try {
      result = (Ogre::PageManager::ContentFactoryMap *) &((Ogre::PageManager const *)arg1)->getContentFactories();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::PageManager.create_content

  call-seq:
    create_content(String typeName) -> PageContent

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_create_content(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;
  }
  {
    try {
      result = (Ogre::PageContent *)(arg1)->createContent((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContent, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.destroy_content

  call-seq:
    destroy_content(PageContent c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_destroy_content(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);
  {
    try {
      (arg1)->destroyContent(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.add_world_section_factory

  call-seq:
    add_world_section_factory(PagedWorldSectionFactory f)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_add_world_section_factory(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);
  {
    try {
      (arg1)->addWorldSectionFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.remove_world_section_factory

  call-seq:
    remove_world_section_factory(PagedWorldSectionFactory f)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_remove_world_section_factory(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);
  {
    try {
      (arg1)->removeWorldSectionFactory(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_world_section_factory

  call-seq:
    get_world_section_factory(String name) -> PagedWorldSectionFactory

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_world_section_factory(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;
  }
  {
    try {
      result = (Ogre::PagedWorldSectionFactory *)(arg1)->getWorldSectionFactory((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSectionFactory, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.create_world_section

  call-seq:
    create_world_section(String typeName, String name, PagedWorld parent, SceneManager sm) -> PagedWorldSection

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_create_world_section(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);
  {
    try {
      result = (Ogre::PagedWorldSection *)(arg1)->createWorldSection((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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;
}



/*
  Document-method: Ogre::PageManager.destroy_world_section

  call-seq:
    destroy_world_section(PagedWorldSection s)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_destroy_world_section(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);
  {
    try {
      (arg1)->destroyWorldSection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_world_section_factories

  call-seq:
    get_world_section_factories -> WorldSectionFactoryMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_world_section_factories(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);
  {
    try {
      result = (Ogre::PageManager::WorldSectionFactoryMap *) &((Ogre::PageManager const *)arg1)->getWorldSectionFactories();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::PageManager.set_page_provider

  call-seq:
    set_page_provider(PageProvider provider)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_set_page_provider(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);
  {
    try {
      (arg1)->setPageProvider(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_page_provider

  call-seq:
    get_page_provider -> PageProvider

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_page_provider(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);
  {
    try {
      result = (Ogre::PageProvider *)((Ogre::PageManager const *)arg1)->getPageProvider();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageProvider, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager._prepare_procedural_page

  call-seq:
    _prepare_procedural_page(Page page, PagedWorldSection section) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager__prepare_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->_prepareProceduralPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager._load_procedural_page

  call-seq:
    _load_procedural_page(Page page, PagedWorldSection section) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager__load_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->_loadProceduralPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager._unload_procedural_page

  call-seq:
    _unload_procedural_page(Page page, PagedWorldSection section) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager__unload_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->_unloadProceduralPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager._unprepare_procedural_page

  call-seq:
    _unprepare_procedural_page(Page page, PagedWorldSection section) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager__unprepare_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->_unprepareProceduralPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager._read_page_stream

  call-seq:
    _read_page_stream(PageID pageID, PagedWorldSection section) -> StreamSerialiser

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager__read_page_stream(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);
  {
    try {
      result = (Ogre::StreamSerialiser *)(arg1)->_readPageStream(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager._write_page_stream

  call-seq:
    _write_page_stream(PageID pageID, PagedWorldSection section) -> StreamSerialiser

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager__write_page_stream(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);
  {
    try {
      result = (Ogre::StreamSerialiser *)(arg1)->_writePageStream(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager._read_world_stream

  call-seq:
    _read_world_stream(String filename) -> StreamSerialiser

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager__read_world_stream(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;
  }
  {
    try {
      result = (Ogre::StreamSerialiser *)(arg1)->_readWorldStream((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PageManager._write_world_stream

  call-seq:
    _write_world_stream(String filename) -> StreamSerialiser

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager__write_world_stream(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;
  }
  {
    try {
      result = (Ogre::StreamSerialiser *)(arg1)->_writeWorldStream((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_page_resource_group

  call-seq:
    get_page_resource_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_page_resource_group(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::PageManager const *)arg1)->getPageResourceGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.set_page_resource_group

  call-seq:
    set_page_resource_group(String g)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_set_page_resource_group(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;
  }
  {
    try {
      (arg1)->setPageResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.add_camera

  call-seq:
    add_camera(Camera c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_add_camera(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);
  {
    try {
      (arg1)->addCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.remove_camera

  call-seq:
    remove_camera(Camera c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_remove_camera(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);
  {
    try {
      (arg1)->removeCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.has_camera

  call-seq:
    has_camera(Camera c) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_has_camera(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);
  {
    try {
      result = (bool)((Ogre::PageManager const *)arg1)->hasCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_camera_list

  call-seq:
    get_camera_list -> CameraList

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_camera_list(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);
  {
    try {
      result = (Ogre::PageManager::CameraList *) &((Ogre::PageManager const *)arg1)->getCameraList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Camera_p_Ogre__STLAllocatorT_Ogre__Camera_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.set_debug_display_level

  call-seq:
    set_debug_display_level(uint8 lvl)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_set_debug_display_level(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);
  {
    try {
      (arg1)->setDebugDisplayLevel(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_debug_display_level

  call-seq:
    get_debug_display_level -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_debug_display_level(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::PageManager const *)arg1)->getDebugDisplayLevel();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.set_paging_operations_enabled

  call-seq:
    set_paging_operations_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_set_paging_operations_enabled(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);
  {
    try {
      (arg1)->setPagingOperationsEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PageManager.get_paging_operations_enabled

  call-seq:
    get_paging_operations_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PageManager_get_paging_operations_enabled(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);
  {
    try {
      result = (bool)((Ogre::PageManager const *)arg1)->getPagingOperationsEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PagedWorld

  Proxy of C++ Ogre::PagedWorld class


*/
swig_class SwigClassPagedWorld;


/*
  Document-method: Ogre::PagedWorld.CHUNK_ID

  call-seq:
    CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::PagedWorld.PagedWorld_CHUNK_ID

  call-seq:
    PagedWorld_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::PagedWorld.CHUNK_VERSION

  call-seq:
    CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::PagedWorld.PagedWorld_CHUNK_VERSION

  call-seq:
    PagedWorld_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::PagedWorld.CHUNK_SECTIONDECLARATION_ID

  call-seq:
    CHUNK_SECTIONDECLARATION_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::PagedWorld.PagedWorld_CHUNK_SECTIONDECLARATION_ID

  call-seq:
    PagedWorld_CHUNK_SECTIONDECLARATION_ID -> uint32

Get value of attribute.

*/
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;
  }
  


/*
  Document-method: Ogre::PagedWorld.new

  call-seq:
    PagedWorld.new(String name, PageManager manager)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::PagedWorld *)new Ogre::PagedWorld((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::PagedWorld.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::PagedWorld const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld.get_manager

  call-seq:
    get_manager -> PageManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_get_manager(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);
  {
    try {
      result = (Ogre::PageManager *)((Ogre::PagedWorld const *)arg1)->getManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld.load

  call-seq:
    load(String filename)
    load(DataStreamPtr stream)
    load(StreamSerialiser stream) -> bool

An instance method.

*/
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;
  }
  {
    try {
      (arg1)->load((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->load((Ogre::DataStreamPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (bool)(arg1)->load(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::PagedWorld.save

  call-seq:
    save(String filename)
    save(DataStreamPtr stream)
    save(StreamSerialiser stream)

An instance method.

*/
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;
  }
  {
    try {
      (arg1)->save((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->save((Ogre::DataStreamPtr const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->save(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::PagedWorld.create_section

  call-seq:
    create_section(SceneManager sceneMgr, String typeName, String sectionName=BLANK) -> PagedWorldSection
    create_section(SceneManager sceneMgr, String typeName) -> PagedWorldSection
    create_section(String strategyName, SceneManager sceneMgr, String sectionName=BLANK) -> PagedWorldSection
    create_section(String strategyName, SceneManager sceneMgr) -> PagedWorldSection
    create_section(PageStrategy strategy, SceneManager sceneMgr, String sectionName=BLANK) -> PagedWorldSection
    create_section(PageStrategy strategy, SceneManager sceneMgr) -> PagedWorldSection

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_create_section__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;
  }
  {
    try {
      result = (Ogre::PagedWorldSection *)(arg1)->createSection(arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_section__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;
  }
  {
    try {
      result = (Ogre::PagedWorldSection *)(arg1)->createSection(arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(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_create_section__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;
  }
  {
    try {
      result = (Ogre::PagedWorldSection *)(arg1)->createSection((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_section__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);
  {
    try {
      result = (Ogre::PagedWorldSection *)(arg1)->createSection((Ogre::String const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_section__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;
  }
  {
    try {
      result = (Ogre::PagedWorldSection *)(arg1)->createSection(arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_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_create_section__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);
  {
    try {
      result = (Ogre::PagedWorldSection *)(arg1)->createSection(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorld_create_section(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_create_section__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_create_section__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_create_section__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_create_section__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_create_section__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_create_section__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "PagedWorld.create_section", 
    "    Ogre::PagedWorldSection * PagedWorld.create_section(Ogre::SceneManager *sceneMgr, Ogre::String const &typeName, Ogre::String const &sectionName)\n"
    "    Ogre::PagedWorldSection * PagedWorld.create_section(Ogre::SceneManager *sceneMgr, Ogre::String const &typeName)\n"
    "    Ogre::PagedWorldSection * PagedWorld.create_section(Ogre::String const &strategyName, Ogre::SceneManager *sceneMgr, Ogre::String const &sectionName)\n"
    "    Ogre::PagedWorldSection * PagedWorld.create_section(Ogre::String const &strategyName, Ogre::SceneManager *sceneMgr)\n"
    "    Ogre::PagedWorldSection * PagedWorld.create_section(Ogre::PageStrategy *strategy, Ogre::SceneManager *sceneMgr, Ogre::String const &sectionName)\n"
    "    Ogre::PagedWorldSection * PagedWorld.create_section(Ogre::PageStrategy *strategy, Ogre::SceneManager *sceneMgr)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld.destroy_section

  call-seq:
    destroy_section(String name)
    destroy_section(PagedWorldSection sec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_destroy_section__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;
  }
  {
    try {
      (arg1)->destroySection((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_destroy_section__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);
  {
    try {
      (arg1)->destroySection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorld_destroy_section(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_destroy_section__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_destroy_section__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PagedWorld.destroy_section", 
    "    void PagedWorld.destroy_section(Ogre::String const &name)\n"
    "    void PagedWorld.destroy_section(Ogre::PagedWorldSection *sec)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld.destroy_all_sections

  call-seq:
    destroy_all_sections

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_destroy_all_sections(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);
  {
    try {
      (arg1)->destroyAllSections();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld.get_section_count

  call-seq:
    get_section_count -> size_t

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_get_section_count(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);
  {
    try {
      result = ((Ogre::PagedWorld const *)arg1)->getSectionCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld.get_section

  call-seq:
    get_section(String name) -> PagedWorldSection

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_get_section(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;
  }
  {
    try {
      result = (Ogre::PagedWorldSection *)(arg1)->getSection((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld.get_sections

  call-seq:
    get_sections -> SectionMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_get_sections(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);
  {
    try {
      result = (Ogre::PagedWorld::SectionMap *) &((Ogre::PagedWorld const *)arg1)->getSections();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
}



/*
  Document-method: Ogre::PagedWorld.set_page_provider

  call-seq:
    set_page_provider(PageProvider provider)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_set_page_provider(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);
  {
    try {
      (arg1)->setPageProvider(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld.get_page_provider

  call-seq:
    get_page_provider -> PageProvider

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_get_page_provider(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);
  {
    try {
      result = (Ogre::PageProvider *)((Ogre::PagedWorld const *)arg1)->getPageProvider();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageProvider, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld._prepare_procedural_page

  call-seq:
    _prepare_procedural_page(Page page, PagedWorldSection section) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld__prepare_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->_prepareProceduralPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld._load_procedural_page

  call-seq:
    _load_procedural_page(Page page, PagedWorldSection section) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld__load_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->_loadProceduralPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld._unload_procedural_page

  call-seq:
    _unload_procedural_page(Page page, PagedWorldSection section) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld__unload_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->_unloadProceduralPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld._unprepare_procedural_page

  call-seq:
    _unprepare_procedural_page(Page page, PagedWorldSection section) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld__unprepare_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->_unprepareProceduralPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld._read_page_stream

  call-seq:
    _read_page_stream(PageID pageID, PagedWorldSection section) -> StreamSerialiser

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld__read_page_stream(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);
  {
    try {
      result = (Ogre::StreamSerialiser *)(arg1)->_readPageStream(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld._write_page_stream

  call-seq:
    _write_page_stream(PageID pageID, PagedWorldSection section) -> StreamSerialiser

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld__write_page_stream(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);
  {
    try {
      result = (Ogre::StreamSerialiser *)(arg1)->_writePageStream(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld.frame_start

  call-seq:
    frame_start(Real timeSinceLastFrame)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_frame_start(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);
  {
    try {
      (arg1)->frameStart(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld.frame_end

  call-seq:
    frame_end(Real timeElapsed)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_frame_end(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);
  {
    try {
      (arg1)->frameEnd(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorld.notify_camera

  call-seq:
    notify_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorld_notify_camera(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);
  {
    try {
      (arg1)->notifyCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PagedWorldSection

  Proxy of C++ Ogre::PagedWorldSection class


*/
swig_class SwigClassPagedWorldSection;


/*
  Document-method: Ogre::PagedWorldSection.CHUNK_ID

  call-seq:
    CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::PagedWorldSection.PagedWorldSection_CHUNK_ID

  call-seq:
    PagedWorldSection_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::PagedWorldSection.CHUNK_VERSION

  call-seq:
    CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::PagedWorldSection.PagedWorldSection_CHUNK_VERSION

  call-seq:
    PagedWorldSection_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
  }
  


/*
  Document-method: Ogre::PagedWorldSection.new

  call-seq:
    PagedWorldSection.new(String name, PagedWorld parent, SceneManager sm)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::PagedWorldSection *)new Ogre::PagedWorldSection((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::PagedWorldSection.get_manager

  call-seq:
    get_manager -> PageManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_get_manager(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);
  {
    try {
      result = (Ogre::PageManager *)((Ogre::PagedWorldSection const *)arg1)->getManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::PagedWorldSection const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.get_strategy

  call-seq:
    get_strategy -> PageStrategy

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_get_strategy(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);
  {
    try {
      result = (Ogre::PageStrategy *)((Ogre::PagedWorldSection const *)arg1)->getStrategy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.set_strategy

  call-seq:
    set_strategy(PageStrategy strat)
    set_strategy(String stratName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_set_strategy__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);
  {
    try {
      (arg1)->setStrategy(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_set_strategy__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;
  }
  {
    try {
      (arg1)->setStrategy((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorldSection_set_strategy(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_set_strategy__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_set_strategy__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PagedWorldSection.set_strategy", 
    "    void PagedWorldSection.set_strategy(Ogre::PageStrategy *strat)\n"
    "    void PagedWorldSection.set_strategy(Ogre::String const &stratName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.set_scene_manager

  call-seq:
    set_scene_manager(SceneManager sm)
    set_scene_manager(String smName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_set_scene_manager__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);
  {
    try {
      (arg1)->setSceneManager(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_set_scene_manager__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;
  }
  {
    try {
      (arg1)->setSceneManager((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorldSection_set_scene_manager(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_set_scene_manager__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_set_scene_manager__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PagedWorldSection.set_scene_manager", 
    "    void PagedWorldSection.set_scene_manager(Ogre::SceneManager *sm)\n"
    "    void PagedWorldSection.set_scene_manager(Ogre::String const &smName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.get_scene_manager

  call-seq:
    get_scene_manager -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_get_scene_manager(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);
  {
    try {
      result = (Ogre::SceneManager *)((Ogre::PagedWorldSection const *)arg1)->getSceneManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.get_world

  call-seq:
    get_world -> PagedWorld

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_get_world(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);
  {
    try {
      result = (Ogre::PagedWorld *)((Ogre::PagedWorldSection const *)arg1)->getWorld();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.get_strategy_data

  call-seq:
    get_strategy_data -> PageStrategyData

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_get_strategy_data(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);
  {
    try {
      result = (Ogre::PageStrategyData *)((Ogre::PagedWorldSection const *)arg1)->getStrategyData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageStrategyData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.set_bounding_box

  call-seq:
    set_bounding_box(AxisAlignedBox box)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_set_bounding_box(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);
  {
    try {
      (arg1)->setBoundingBox((Ogre::AxisAlignedBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.get_bounding_box

  call-seq:
    get_bounding_box -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_get_bounding_box(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::PagedWorldSection const *)arg1)->getBoundingBox();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.load

  call-seq:
    load(StreamSerialiser stream) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)(arg1)->load(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.save

  call-seq:
    save(StreamSerialiser stream)

An instance method.

*/
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);
  {
    try {
      (arg1)->save(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.frame_start

  call-seq:
    frame_start(Real timeSinceLastFrame)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_frame_start(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);
  {
    try {
      (arg1)->frameStart(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.frame_end

  call-seq:
    frame_end(Real timeElapsed)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_frame_end(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);
  {
    try {
      (arg1)->frameEnd(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.notify_camera

  call-seq:
    notify_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_notify_camera(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);
  {
    try {
      (arg1)->notifyCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.load_or_create_page

  call-seq:
    load_or_create_page(Vector3 worldPos) -> Page

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_load_or_create_page(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);
  {
    try {
      result = (Ogre::Page *)(arg1)->loadOrCreatePage((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Page, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.get_page_id

  call-seq:
    get_page_id(Vector3 worldPos) -> PageID

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_get_page_id(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);
  {
    try {
      result = (Ogre::PageID)(arg1)->getPageID((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.load_page

  call-seq:
    load_page(PageID pageID, bool forceSynchronous=false)
    load_page(PageID pageID)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_load_page__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);
  {
    try {
      (arg1)->loadPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_load_page__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);
  {
    try {
      (arg1)->loadPage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorldSection_load_page(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_load_page__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_load_page__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "PagedWorldSection.load_page", 
    "    void PagedWorldSection.load_page(Ogre::PageID pageID, bool forceSynchronous)\n"
    "    void PagedWorldSection.load_page(Ogre::PageID pageID)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.unload_page

  call-seq:
    unload_page(PageID pageID, bool forceSynchronous=false)
    unload_page(PageID pageID)
    unload_page(Page p, bool forceSynchronous=false)
    unload_page(Page p)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_unload_page__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);
  {
    try {
      (arg1)->unloadPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_unload_page__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);
  {
    try {
      (arg1)->unloadPage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_unload_page__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);
  {
    try {
      (arg1)->unloadPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_unload_page__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);
  {
    try {
      (arg1)->unloadPage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorldSection_unload_page(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_unload_page__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_unload_page__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_unload_page__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_unload_page__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "PagedWorldSection.unload_page", 
    "    void PagedWorldSection.unload_page(Ogre::PageID pageID, bool forceSynchronous)\n"
    "    void PagedWorldSection.unload_page(Ogre::PageID pageID)\n"
    "    void PagedWorldSection.unload_page(Ogre::Page *p, bool forceSynchronous)\n"
    "    void PagedWorldSection.unload_page(Ogre::Page *p)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection._prepare_procedural_page

  call-seq:
    _prepare_procedural_page(Page page) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection__prepare_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->_prepareProceduralPage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection._load_procedural_page

  call-seq:
    _load_procedural_page(Page page) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection__load_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->_loadProceduralPage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection._unload_procedural_page

  call-seq:
    _unload_procedural_page(Page page) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection__unload_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->_unloadProceduralPage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection._unprepare_procedural_page

  call-seq:
    _unprepare_procedural_page(Page page) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection__unprepare_procedural_page(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);
  {
    try {
      result = (bool)(arg1)->_unprepareProceduralPage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.hold_page

  call-seq:
    hold_page(PageID pageID)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_hold_page(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);
  {
    try {
      (arg1)->holdPage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.get_page

  call-seq:
    get_page(PageID pageID) -> Page

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_get_page(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);
  {
    try {
      result = (Ogre::Page *)(arg1)->getPage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Page, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.remove_all_pages

  call-seq:
    remove_all_pages

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_remove_all_pages(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);
  {
    try {
      (arg1)->removeAllPages();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.set_page_provider

  call-seq:
    set_page_provider(PageProvider provider)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_set_page_provider(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);
  {
    try {
      (arg1)->setPageProvider(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.get_page_provider

  call-seq:
    get_page_provider -> PageProvider

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_get_page_provider(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);
  {
    try {
      result = (Ogre::PageProvider *)((Ogre::PagedWorldSection const *)arg1)->getPageProvider();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageProvider, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection._read_page_stream

  call-seq:
    _read_page_stream(PageID pageID) -> StreamSerialiser

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection__read_page_stream(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);
  {
    try {
      result = (Ogre::StreamSerialiser *)(arg1)->_readPageStream(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection._write_page_stream

  call-seq:
    _write_page_stream(PageID pageID) -> StreamSerialiser

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection__write_page_stream(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);
  {
    try {
      result = (Ogre::StreamSerialiser *)(arg1)->_writePageStream(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSection.get_type

  call-seq:
    get_type -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSection_get_type(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);
  {
    try {
      result = (Ogre::String *) &(arg1)->getType();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::PagedWorldSectionFactory

  Proxy of C++ Ogre::PagedWorldSectionFactory class


*/
swig_class SwigClassPagedWorldSectionFactory;

SWIGINTERN void
free_Ogre_PagedWorldSectionFactory(Ogre::PagedWorldSectionFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::PagedWorldSectionFactory.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSectionFactory_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::PagedWorldSectionFactory const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSectionFactory.create_instance

  call-seq:
    create_instance(String name, PagedWorld parent, SceneManager sm) -> PagedWorldSection

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSectionFactory_create_instance(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);
  {
    try {
      result = (Ogre::PagedWorldSection *)(arg1)->createInstance((Ogre::String const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::PagedWorldSectionFactory.destroy_instance

  call-seq:
    destroy_instance(PagedWorldSection ?)

An instance method.

*/
SWIGINTERN VALUE
_wrap_PagedWorldSectionFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::SimplePageContentCollection < Ogre::Ogre::PageContentCollection

  Proxy of C++ Ogre::SimplePageContentCollection class


*/
swig_class SwigClassSimplePageContentCollection;


/*
  Document-method: Ogre::SimplePageContentCollection.SUBCLASS_CHUNK_ID

  call-seq:
    SUBCLASS_CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::SimplePageContentCollection.SimplePageContentCollection_SUBCLASS_CHUNK_ID

  call-seq:
    SimplePageContentCollection_SUBCLASS_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::SimplePageContentCollection.SUBCLASS_CHUNK_VERSION

  call-seq:
    SUBCLASS_CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::SimplePageContentCollection.SimplePageContentCollection_SUBCLASS_CHUNK_VERSION

  call-seq:
    SimplePageContentCollection_SUBCLASS_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
  }
  


/*
  Document-method: Ogre::SimplePageContentCollection.new

  call-seq:
    SimplePageContentCollection.new(PageContentCollectionFactory creator)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::SimplePageContentCollection *)new Ogre::SimplePageContentCollection(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SimplePageContentCollection(Ogre::SimplePageContentCollection *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SimplePageContentCollection.create_content

  call-seq:
    create_content(String typeName) -> PageContent

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimplePageContentCollection_create_content(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;
  }
  {
    try {
      result = (Ogre::PageContent *)(arg1)->createContent((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContent, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::SimplePageContentCollection.destroy_content

  call-seq:
    destroy_content(PageContent coll)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimplePageContentCollection_destroy_content(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);
  {
    try {
      (arg1)->destroyContent(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimplePageContentCollection.get_content_list

  call-seq:
    get_content_list -> ContentList

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimplePageContentCollection_get_content_list(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);
  {
    try {
      result = (Ogre::SimplePageContentCollection::ContentList *) &((Ogre::SimplePageContentCollection const *)arg1)->getContentList();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__PageContent_p_Ogre__STLAllocatorT_Ogre__PageContent_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimplePageContentCollection.save

  call-seq:
    save(StreamSerialiser stream)

An instance method.

*/
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);
  {
    try {
      (arg1)->save(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimplePageContentCollection.frame_start

  call-seq:
    frame_start(Real timeSinceLastFrame)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimplePageContentCollection_frame_start(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);
  {
    try {
      (arg1)->frameStart(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimplePageContentCollection.frame_end

  call-seq:
    frame_end(Real timeElapsed)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimplePageContentCollection_frame_end(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);
  {
    try {
      (arg1)->frameEnd(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimplePageContentCollection.notify_camera

  call-seq:
    notify_camera(Camera cam)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimplePageContentCollection_notify_camera(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);
  {
    try {
      (arg1)->notifyCamera(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimplePageContentCollection.prepare

  call-seq:
    prepare(StreamSerialiser stream) -> bool

An instance method.

*/
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);
  {
    try {
      result = (bool)(arg1)->prepare(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimplePageContentCollection.load

  call-seq:
    load

An instance method.

*/
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);
  {
    try {
      (arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimplePageContentCollection.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimplePageContentCollection.unprepare

  call-seq:
    unprepare

An instance method.

*/
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);
  {
    try {
      (arg1)->unprepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::SimplePageContentCollectionFactory < Ogre::Ogre::PageContentCollectionFactory

  Proxy of C++ Ogre::SimplePageContentCollectionFactory class


*/
swig_class SwigClassSimplePageContentCollectionFactory;


/*
  Document-method: Ogre::SimplePageContentCollectionFactory.FACTORY_NAME

  call-seq:
    FACTORY_NAME -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::SimplePageContentCollectionFactory.FACTORY_NAME=

  call-seq:
    FACTORY_NAME=(x) -> String

Set new value for attribute.

*/

/*
  Document-method: Ogre::SimplePageContentCollectionFactory.SimplePageContentCollectionFactory_FACTORY_NAME

  call-seq:
    SimplePageContentCollectionFactory_FACTORY_NAME -> String

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::SimplePageContentCollectionFactory.SimplePageContentCollectionFactory_FACTORY_NAME=

  call-seq:
    SimplePageContentCollectionFactory_FACTORY_NAME=(x) -> String

Set new value for attribute.

*/
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;
  }
  


/*
  Document-method: Ogre::SimplePageContentCollectionFactory.new

  call-seq:
    SimplePageContentCollectionFactory.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::SimplePageContentCollectionFactory *)new Ogre::SimplePageContentCollectionFactory();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SimplePageContentCollectionFactory(Ogre::SimplePageContentCollectionFactory *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::SimplePageContentCollectionFactory.get_name

  call-seq:
    get_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimplePageContentCollectionFactory_get_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::SimplePageContentCollectionFactory const *)arg1)->getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimplePageContentCollectionFactory.create_instance

  call-seq:
    create_instance -> PageContentCollection

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimplePageContentCollectionFactory_create_instance(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);
  {
    try {
      result = (Ogre::PageContentCollection *)(arg1)->createInstance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimplePageContentCollectionFactory.destroy_instance

  call-seq:
    destroy_instance(PageContentCollection c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_SimplePageContentCollectionFactory_destroy_instance(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);
  {
    try {
      (arg1)->destroyInstance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::TerrainGroup

  Proxy of C++ Ogre::TerrainGroup class


*/
swig_class SwigClassTerrainGroup;


/*
  Document-method: Ogre::TerrainGroup.new

  call-seq:
    TerrainGroup.new(SceneManager sm, Alignment align, uint16 terrainSize, 
    Real terrainWorldSize)
    TerrainGroup.new(SceneManager sm)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::TerrainGroup *)new Ogre::TerrainGroup(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#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);
  {
    try {
      result = (Ogre::TerrainGroup *)new Ogre::TerrainGroup(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-method: Ogre::TerrainGroup.get_default_import_settings

  call-seq:
    get_default_import_settings -> ImportData

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_default_import_settings(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);
  {
    try {
      result = (Ogre::Terrain::ImportData *) &(arg1)->getDefaultImportSettings();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain__ImportData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.set_origin

  call-seq:
    set_origin(Vector3 pos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_set_origin(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);
  {
    try {
      (arg1)->setOrigin((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.get_origin

  call-seq:
    get_origin -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_origin(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::TerrainGroup const *)arg1)->getOrigin();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.get_alignment

  call-seq:
    get_alignment -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_alignment(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);
  {
    try {
      result = (Ogre::Terrain::Alignment)((Ogre::TerrainGroup const *)arg1)->getAlignment();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.get_terrain_world_size

  call-seq:
    get_terrain_world_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_terrain_world_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TerrainGroup const *)arg1)->getTerrainWorldSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.set_terrain_world_size

  call-seq:
    set_terrain_world_size(Real newWorldSize)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_set_terrain_world_size(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);
  {
    try {
      (arg1)->setTerrainWorldSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.get_terrain_size

  call-seq:
    get_terrain_size -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_terrain_size(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::TerrainGroup const *)arg1)->getTerrainSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.set_terrain_size

  call-seq:
    set_terrain_size(uint16 newTerrainSize)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_set_terrain_size(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);
  {
    try {
      (arg1)->setTerrainSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.get_scene_manager

  call-seq:
    get_scene_manager -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_scene_manager(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);
  {
    try {
      result = (Ogre::SceneManager *)((Ogre::TerrainGroup const *)arg1)->getSceneManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.set_filename_convention

  call-seq:
    set_filename_convention(String prefix, String extension)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_set_filename_convention(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;
  }
  {
    try {
      (arg1)->setFilenameConvention((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::TerrainGroup.set_filename_prefix

  call-seq:
    set_filename_prefix(String prefix)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_set_filename_prefix(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;
  }
  {
    try {
      (arg1)->setFilenamePrefix((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.set_filename_extension

  call-seq:
    set_filename_extension(String extension)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_set_filename_extension(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;
  }
  {
    try {
      (arg1)->setFilenameExtension((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.get_filename_prefix

  call-seq:
    get_filename_prefix -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_filename_prefix(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::TerrainGroup const *)arg1)->getFilenamePrefix();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.get_filename_extension

  call-seq:
    get_filename_extension -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_filename_extension(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::TerrainGroup const *)arg1)->getFilenameExtension();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.set_resource_group

  call-seq:
    set_resource_group(String grp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_set_resource_group(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;
  }
  {
    try {
      (arg1)->setResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.get_resource_group

  call-seq:
    get_resource_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_resource_group(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::TerrainGroup const *)arg1)->getResourceGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.define_terrain

  call-seq:
    define_terrain(long x, long y)
    define_terrain(long x, long y, float constantHeight)
    define_terrain(long x, long y, ImportData importData)
    define_terrain(long x, long y, Image img, LayerInstanceList layers=0)
    define_terrain(long x, long y, Image img)
    define_terrain(long x, long y, float pFloat, LayerInstanceList layers=0)
    define_terrain(long x, long y, float pFloat)
    define_terrain(long x, long y, String filename)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_define_terrain__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);
  {
    try {
      (arg1)->defineTerrain(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_define_terrain__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);
  {
    try {
      (arg1)->defineTerrain(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_define_terrain__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);
  {
    try {
      (arg1)->defineTerrain(arg2,arg3,(Ogre::Terrain::ImportData const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_define_terrain__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);
  {
    try {
      (arg1)->defineTerrain(arg2,arg3,(Ogre::Image const *)arg4,(Ogre::Terrain::LayerInstanceList const *)arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_define_terrain__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);
  {
    try {
      (arg1)->defineTerrain(arg2,arg3,(Ogre::Image const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_define_terrain__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);
  {
    try {
      (arg1)->defineTerrain(arg2,arg3,(float const *)arg4,(Ogre::Terrain::LayerInstanceList const *)arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_define_terrain__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);
  {
    try {
      (arg1)->defineTerrain(arg2,arg3,(float const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_define_terrain__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;
  }
  {
    try {
      (arg1)->defineTerrain(arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_define_terrain(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_define_terrain__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_define_terrain__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_define_terrain__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_define_terrain__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_define_terrain__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_define_terrain__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_define_terrain__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_define_terrain__SWIG_5(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "TerrainGroup.define_terrain", 
    "    void TerrainGroup.define_terrain(long x, long y)\n"
    "    void TerrainGroup.define_terrain(long x, long y, float constantHeight)\n"
    "    void TerrainGroup.define_terrain(long x, long y, Ogre::Terrain::ImportData const *importData)\n"
    "    void TerrainGroup.define_terrain(long x, long y, Ogre::Image const *img, Ogre::Terrain::LayerInstanceList const *layers)\n"
    "    void TerrainGroup.define_terrain(long x, long y, Ogre::Image const *img)\n"
    "    void TerrainGroup.define_terrain(long x, long y, float const *pFloat, Ogre::Terrain::LayerInstanceList const *layers)\n"
    "    void TerrainGroup.define_terrain(long x, long y, float const *pFloat)\n"
    "    void TerrainGroup.define_terrain(long x, long y, Ogre::String const &filename)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.load_all_terrains

  call-seq:
    load_all_terrains(bool synchronous=false)
    load_all_terrains

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_load_all_terrains__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);
  {
    try {
      (arg1)->loadAllTerrains(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_load_all_terrains__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);
  {
    try {
      (arg1)->loadAllTerrains();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_load_all_terrains(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_load_all_terrains__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_load_all_terrains__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TerrainGroup.load_all_terrains", 
    "    void TerrainGroup.load_all_terrains(bool synchronous)\n"
    "    void TerrainGroup.load_all_terrains()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.load_terrain

  call-seq:
    load_terrain(long x, long y, bool synchronous=false)
    load_terrain(long x, long y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_load_terrain__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);
  {
    try {
      (arg1)->loadTerrain(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_load_terrain__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);
  {
    try {
      (arg1)->loadTerrain(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_load_terrain(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_load_terrain__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_load_terrain__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TerrainGroup.load_terrain", 
    "    void TerrainGroup.load_terrain(long x, long y, bool synchronous)\n"
    "    void TerrainGroup.load_terrain(long x, long y)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.unload_terrain

  call-seq:
    unload_terrain(long x, long y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_unload_terrain(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);
  {
    try {
      (arg1)->unloadTerrain(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.remove_terrain

  call-seq:
    remove_terrain(long x, long y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_remove_terrain(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);
  {
    try {
      (arg1)->removeTerrain(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.remove_all_terrains

  call-seq:
    remove_all_terrains

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_remove_all_terrains(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);
  {
    try {
      (arg1)->removeAllTerrains();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.save_all_terrains

  call-seq:
    save_all_terrains(bool onlyIfModified, bool replaceManualFilenames=true)
    save_all_terrains(bool onlyIfModified)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_save_all_terrains__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);
  {
    try {
      (arg1)->saveAllTerrains(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_save_all_terrains__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);
  {
    try {
      (arg1)->saveAllTerrains(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_save_all_terrains(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_save_all_terrains__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_save_all_terrains__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainGroup.save_all_terrains", 
    "    void TerrainGroup.save_all_terrains(bool onlyIfModified, bool replaceManualFilenames)\n"
    "    void TerrainGroup.save_all_terrains(bool onlyIfModified)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.get_terrain_definition

  call-seq:
    get_terrain_definition(long x, long y) -> TerrainSlotDefinition

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_terrain_definition(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);
  {
    try {
      result = (Ogre::TerrainGroup::TerrainSlotDefinition *)((Ogre::TerrainGroup const *)arg1)->getTerrainDefinition(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainGroup__TerrainSlotDefinition, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.get_terrain

  call-seq:
    get_terrain(long x, long y) -> Terrain

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_terrain(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);
  {
    try {
      result = (Ogre::Terrain *)((Ogre::TerrainGroup const *)arg1)->getTerrain(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.free_temporary_resources

  call-seq:
    free_temporary_resources

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_free_temporary_resources(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);
  {
    try {
      (arg1)->freeTemporaryResources();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.update

  call-seq:
    update(bool synchronous=false)
    update

An instance method.

*/
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);
  {
    try {
      (arg1)->update(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->update();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::TerrainGroup.update_geometry

  call-seq:
    update_geometry

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_update_geometry(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);
  {
    try {
      (arg1)->updateGeometry();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.update_derived_data

  call-seq:
    update_derived_data(bool synchronous=false, uint8 typeMask=0xFF)
    update_derived_data(bool synchronous=false)
    update_derived_data

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_update_derived_data__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);
  {
    try {
      (arg1)->updateDerivedData(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_update_derived_data__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);
  {
    try {
      (arg1)->updateDerivedData(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_update_derived_data__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);
  {
    try {
      (arg1)->updateDerivedData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_update_derived_data(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_update_derived_data__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_update_derived_data__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_update_derived_data__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainGroup.update_derived_data", 
    "    void TerrainGroup.update_derived_data(bool synchronous, Ogre::uint8 typeMask)\n"
    "    void TerrainGroup.update_derived_data(bool synchronous)\n"
    "    void TerrainGroup.update_derived_data()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.get_height_at_world_position

  call-seq:
    get_height_at_world_position(Real x, Real y, Real z, Terrain ppTerrain=0) -> float
    get_height_at_world_position(Real x, Real y, Real z) -> float
    get_height_at_world_position(Vector3 pos, Terrain ppTerrain=0) -> float
    get_height_at_world_position(Vector3 pos) -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_height_at_world_position__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);
  {
    try {
      result = (float)(arg1)->getHeightAtWorldPosition(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_get_height_at_world_position__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);
  {
    try {
      result = (float)(arg1)->getHeightAtWorldPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_get_height_at_world_position__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);
  {
    try {
      result = (float)(arg1)->getHeightAtWorldPosition((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_get_height_at_world_position__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);
  {
    try {
      result = (float)(arg1)->getHeightAtWorldPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_get_height_at_world_position(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_get_height_at_world_position__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_get_height_at_world_position__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_get_height_at_world_position__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_get_height_at_world_position__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "TerrainGroup.get_height_at_world_position", 
    "    float TerrainGroup.get_height_at_world_position(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Terrain **ppTerrain)\n"
    "    float TerrainGroup.get_height_at_world_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    float TerrainGroup.get_height_at_world_position(Ogre::Vector3 const &pos, Ogre::Terrain **ppTerrain)\n"
    "    float TerrainGroup.get_height_at_world_position(Ogre::Vector3 const &pos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.ray_intersects

  call-seq:
    ray_intersects(Ray ray, Real distanceLimit=0) -> RayResult
    ray_intersects(Ray ray) -> RayResult

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_ray_intersects__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);
  {
    try {
      result = ((Ogre::TerrainGroup const *)arg1)->rayIntersects((Ogre::Ray const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_ray_intersects__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);
  {
    try {
      result = ((Ogre::TerrainGroup const *)arg1)->rayIntersects((Ogre::Ray const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_ray_intersects(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_ray_intersects__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_ray_intersects__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainGroup.ray_intersects", 
    "    Ogre::TerrainGroup::RayResult TerrainGroup.ray_intersects(Ogre::Ray const &ray, Ogre::Real distanceLimit)\n"
    "    Ogre::TerrainGroup::RayResult TerrainGroup.ray_intersects(Ogre::Ray const &ray)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.box_intersects

  call-seq:
    box_intersects(AxisAlignedBox box, TerrainList resultList)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_box_intersects(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);
  {
    try {
      ((Ogre::TerrainGroup const *)arg1)->boxIntersects((Ogre::AxisAlignedBox const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.sphere_intersects

  call-seq:
    sphere_intersects(Sphere sphere, TerrainList resultList)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_sphere_intersects(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);
  {
    try {
      ((Ogre::TerrainGroup const *)arg1)->sphereIntersects((Ogre::Sphere const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.convert_world_position_to_terrain_slot

  call-seq:
    convert_world_position_to_terrain_slot(Vector3 pos, long x, long y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_convert_world_position_to_terrain_slot(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);
  {
    try {
      ((Ogre::TerrainGroup const *)arg1)->convertWorldPositionToTerrainSlot((Ogre::Vector3 const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.convert_terrain_slot_to_world_position

  call-seq:
    convert_terrain_slot_to_world_position(long x, long y, Vector3 pos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_convert_terrain_slot_to_world_position(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);
  {
    try {
      ((Ogre::TerrainGroup const *)arg1)->convertTerrainSlotToWorldPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.is_derived_data_update_in_progress

  call-seq:
    is_derived_data_update_in_progress -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_is_derived_data_update_in_progress(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);
  {
    try {
      result = (bool)((Ogre::TerrainGroup const *)arg1)->isDerivedDataUpdateInProgress();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.get_terrain_iterator

  call-seq:
    get_terrain_iterator -> TerrainIterator
    get_terrain_iterator -> ConstTerrainIterator

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_get_terrain_iterator__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);
  {
    try {
      result = (arg1)->getTerrainIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_terrain_iterator__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);
  {
    try {
      result = ((Ogre::TerrainGroup const *)arg1)->getTerrainIterator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::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_get_terrain_iterator(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_get_terrain_iterator__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_get_terrain_iterator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TerrainGroup.get_terrain_iterator", 
    "    Ogre::TerrainGroup::ConstTerrainIterator TerrainGroup.get_terrain_iterator()\n"
    "    Ogre::TerrainGroup::ConstTerrainIterator TerrainGroup.get_terrain_iterator()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.can_handle_request

  call-seq:
    can_handle_request(Request req, WorkQueue srcQ) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_can_handle_request(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);
  {
    try {
      result = (bool)(arg1)->canHandleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.handle_request

  call-seq:
    handle_request(Request req, WorkQueue srcQ) -> Response

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_handle_request(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);
  {
    try {
      result = (Ogre::WorkQueue::Response *)(arg1)->handleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.can_handle_response

  call-seq:
    can_handle_response(Response res, WorkQueue srcQ) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_can_handle_response(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);
  {
    try {
      result = (bool)(arg1)->canHandleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.handle_response

  call-seq:
    handle_response(Response res, WorkQueue srcQ)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_handle_response(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);
  {
    try {
      (arg1)->handleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.pack_index

  call-seq:
    pack_index(long x, long y) -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_pack_index(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::TerrainGroup const *)arg1)->packIndex(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.unpack_index

  call-seq:
    unpack_index(uint32 key, long x, long y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_unpack_index(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);
  {
    try {
      (arg1)->unpackIndex(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.generate_filename

  call-seq:
    generate_filename(long x, long y) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_generate_filename(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);
  {
    try {
      result = ((Ogre::TerrainGroup const *)arg1)->generateFilename(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.save_group_definition

  call-seq:
    save_group_definition(String filename)
    save_group_definition(StreamSerialiser stream)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_save_group_definition__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;
  }
  {
    try {
      (arg1)->saveGroupDefinition((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_save_group_definition__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);
  {
    try {
      (arg1)->saveGroupDefinition(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_save_group_definition(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_save_group_definition__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_save_group_definition__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TerrainGroup.save_group_definition", 
    "    void TerrainGroup.save_group_definition(Ogre::String const &filename)\n"
    "    void TerrainGroup.save_group_definition(Ogre::StreamSerialiser &stream)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.load_group_definition

  call-seq:
    load_group_definition(String filename)
    load_group_definition(StreamSerialiser stream)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_load_group_definition__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;
  }
  {
    try {
      (arg1)->loadGroupDefinition((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_load_group_definition__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);
  {
    try {
      (arg1)->loadGroupDefinition(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_load_group_definition(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_load_group_definition__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_load_group_definition__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TerrainGroup.load_group_definition", 
    "    void TerrainGroup.load_group_definition(Ogre::String const &filename)\n"
    "    void TerrainGroup.load_group_definition(Ogre::StreamSerialiser &stream)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.WORKQUEUE_LOAD_REQUEST

  call-seq:
    WORKQUEUE_LOAD_REQUEST -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainGroup.TerrainGroup_WORKQUEUE_LOAD_REQUEST

  call-seq:
    TerrainGroup_WORKQUEUE_LOAD_REQUEST -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::TerrainGroup.CHUNK_ID

  call-seq:
    CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainGroup.TerrainGroup_CHUNK_ID

  call-seq:
    TerrainGroup_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::TerrainGroup.CHUNK_VERSION

  call-seq:
    CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainGroup.TerrainGroup_CHUNK_VERSION

  call-seq:
    TerrainGroup_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::TerrainGroup.set_default_import_settings

  call-seq:
    set_default_import_settings(float y)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_set_default_import_settings(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);
  {
    try {
      Ogre_TerrainGroup_setDefaultImportSettings(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGroup.init_blend_maps

  call-seq:
    init_blend_maps

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGroup_init_blend_maps(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);
  {
    try {
      Ogre_TerrainGroup_initBlendMaps(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::TerrainLayerBlendMap

  Proxy of C++ Ogre::TerrainLayerBlendMap class


*/
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;
  }
  


/*
  Document-method: Ogre::TerrainLayerBlendMap.new

  call-seq:
    TerrainLayerBlendMap.new(Terrain parent, uint8 layerIndex, HardwarePixelBuffer buf)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::TerrainLayerBlendMap *)new Ogre::TerrainLayerBlendMap(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainLayerBlendMap(Ogre::TerrainLayerBlendMap *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::TerrainLayerBlendMap.get_parent

  call-seq:
    get_parent -> Terrain

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_get_parent(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);
  {
    try {
      result = (Ogre::Terrain *)((Ogre::TerrainLayerBlendMap const *)arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.get_layer_index

  call-seq:
    get_layer_index -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_get_layer_index(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::TerrainLayerBlendMap const *)arg1)->getLayerIndex();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.convert_world_to_uvspace

  call-seq:
    convert_world_to_uvspace(Vector3 worldPos, Real outX, Real outY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_convert_world_to_uvspace(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);
  {
    try {
      (arg1)->convertWorldToUVSpace((Ogre::Vector3 const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.convert_uvto_world_space

  call-seq:
    convert_uvto_world_space(Real x, Real y, Vector3 outWorldPos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_convert_uvto_world_space(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);
  {
    try {
      (arg1)->convertUVToWorldSpace(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.convert_uvto_image_space

  call-seq:
    convert_uvto_image_space(Real x, Real y, size_t outX, size_t outY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_convert_uvto_image_space(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);
  {
    try {
      (arg1)->convertUVToImageSpace(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.convert_image_to_uvspace

  call-seq:
    convert_image_to_uvspace(size_t x, size_t y, Real outX, Real outY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_convert_image_to_uvspace(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);
  {
    try {
      (arg1)->convertImageToUVSpace(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.convert_image_to_terrain_space

  call-seq:
    convert_image_to_terrain_space(size_t x, size_t y, Real outX, Real outY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_convert_image_to_terrain_space(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);
  {
    try {
      (arg1)->convertImageToTerrainSpace(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.convert_terrain_to_image_space

  call-seq:
    convert_terrain_to_image_space(Real x, Real y, size_t outX, size_t outY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_convert_terrain_to_image_space(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);
  {
    try {
      (arg1)->convertTerrainToImageSpace(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.get_blend_value

  call-seq:
    get_blend_value(size_t x, size_t y) -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_get_blend_value(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);
  {
    try {
      result = (float)(arg1)->getBlendValue(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.set_blend_value

  call-seq:
    set_blend_value(size_t x, size_t y, float val)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_set_blend_value(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);
  {
    try {
      (arg1)->setBlendValue(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.get_blend_pointer

  call-seq:
    get_blend_pointer -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_get_blend_pointer(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);
  {
    try {
      result = (float *)(arg1)->getBlendPointer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.dirty

  call-seq:
    dirty

An instance method.

*/
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);
  {
    try {
      (arg1)->dirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.dirty_rect

  call-seq:
    dirty_rect(Rect rect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_dirty_rect(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);
  {
    try {
      (arg1)->dirtyRect((Ogre::Rect const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.blit

  call-seq:
    blit(PixelBox src, Box dstBox)
    blit(PixelBox src)

An instance method.

*/
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);
  {
    try {
      (arg1)->blit((Ogre::PixelBox const &)*arg2,(Ogre::Box const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->blit((Ogre::PixelBox const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.load_image

  call-seq:
    load_image(Image img)
    load_image(DataStreamPtr stream, String ext=BLANK)
    load_image(DataStreamPtr stream)
    load_image(String filename, String groupName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_load_image__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);
  {
    try {
      (arg1)->loadImage((Ogre::Image const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_load_image__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;
  }
  {
    try {
      (arg1)->loadImage(*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_load_image__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);
  {
    try {
      (arg1)->loadImage(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_load_image__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;
  }
  {
    try {
      (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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_load_image(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_load_image__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_load_image__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_load_image__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_load_image__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainLayerBlendMap.load_image", 
    "    void TerrainLayerBlendMap.load_image(Ogre::Image const &img)\n"
    "    void TerrainLayerBlendMap.load_image(Ogre::DataStreamPtr &stream, Ogre::String const &ext)\n"
    "    void TerrainLayerBlendMap.load_image(Ogre::DataStreamPtr &stream)\n"
    "    void TerrainLayerBlendMap.load_image(Ogre::String const &filename, Ogre::String const &groupName)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerBlendMap.update

  call-seq:
    update

An instance method.

*/
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);
  {
    try {
      (arg1)->update();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::TerrainLayerSamplerElement

  Proxy of C++ Ogre::TerrainLayerSamplerElement class


*/
swig_class SwigClassTerrainLayerSamplerElement;


/*
  Document-method: Ogre::TerrainLayerSamplerElement.source

  call-seq:
    source -> uint8

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainLayerSamplerElement.source=

  call-seq:
    source=(x) -> uint8

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::TerrainLayerSamplerElement.semantic

  call-seq:
    semantic -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainLayerSamplerElement.semantic=

  call-seq:
    semantic=(x) -> int

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::TerrainLayerSamplerElement.elementStart

  call-seq:
    elementStart -> uint8

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainLayerSamplerElement.elementStart=

  call-seq:
    elementStart=(x) -> uint8

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::TerrainLayerSamplerElement.elementCount

  call-seq:
    elementCount -> uint8

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainLayerSamplerElement.elementCount=

  call-seq:
    elementCount=(x) -> uint8

Set new value for attribute.

*/
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);
  {
    try {
      result = (bool)((Ogre::TerrainLayerSamplerElement const *)arg1)->operator ==((Ogre::TerrainLayerSamplerElement const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerSamplerElement.new

  call-seq:
    TerrainLayerSamplerElement.new
    TerrainLayerSamplerElement.new(uint8 src, TerrainLayerSamplerSemantic sem, uint8 elemStart, 
    uint8 elemCount)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TerrainLayerSamplerElement *)new Ogre::TerrainLayerSamplerElement();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::TerrainLayerSamplerElement *)new Ogre::TerrainLayerSamplerElement(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_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;
}


/*
  Document-class: Ogre::TerrainLayerSampler

  Proxy of C++ Ogre::TerrainLayerSampler class


*/
swig_class SwigClassTerrainLayerSampler;


/*
  Document-method: Ogre::TerrainLayerSampler.alias

  call-seq:
    alias -> String

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainLayerSampler.alias=

  call-seq:
    alias=(x) -> String

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::TerrainLayerSampler.format

  call-seq:
    format -> int

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainLayerSampler.format=

  call-seq:
    format=(x) -> int

Set new value for attribute.

*/
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);
  {
    try {
      result = (bool)((Ogre::TerrainLayerSampler const *)arg1)->operator ==((Ogre::TerrainLayerSampler const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerSampler.new

  call-seq:
    TerrainLayerSampler.new
    TerrainLayerSampler.new(String aliasName, PixelFormat fmt)

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TerrainLayerSampler *)new Ogre::TerrainLayerSampler();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (Ogre::TerrainLayerSampler *)new Ogre::TerrainLayerSampler((Ogre::String const &)*arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-class: Ogre::TerrainLayerDeclaration

  Proxy of C++ Ogre::TerrainLayerDeclaration class


*/
swig_class SwigClassTerrainLayerDeclaration;


/*
  Document-method: Ogre::TerrainLayerDeclaration.samplers

  call-seq:
    samplers -> TerrainLayerSamplerList

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainLayerDeclaration.samplers=

  call-seq:
    samplers=(x) -> TerrainLayerSamplerList

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::TerrainLayerDeclaration.elements

  call-seq:
    elements -> TerrainLayerSamplerElementList

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainLayerDeclaration.elements=

  call-seq:
    elements=(x) -> TerrainLayerSamplerElementList

Set new value for attribute.

*/
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);
  {
    try {
      result = (bool)((Ogre::TerrainLayerDeclaration const *)arg1)->operator ==((Ogre::TerrainLayerDeclaration const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


#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;
  }
  


/*
  Document-method: Ogre::TerrainLayerDeclaration.new

  call-seq:
    TerrainLayerDeclaration.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TerrainLayerDeclaration *)new Ogre::TerrainLayerDeclaration();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainLayerDeclaration(Ogre::TerrainLayerDeclaration *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::TerrainMaterialGenerator

  Proxy of C++ Ogre::TerrainMaterialGenerator class


*/
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;
  }
  


/*
  Document-method: Ogre::TerrainMaterialGenerator.new

  call-seq:
    TerrainMaterialGenerator.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TerrainMaterialGenerator *)new Ogre::TerrainMaterialGenerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainMaterialGenerator(Ogre::TerrainMaterialGenerator *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::TerrainMaterialGenerator.get_profiles

  call-seq:
    get_profiles -> ProfileList

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_get_profiles(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);
  {
    try {
      result = (Ogre::TerrainMaterialGenerator::ProfileList *) &((Ogre::TerrainMaterialGenerator const *)arg1)->getProfiles();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Profile_p_Ogre__STLAllocatorT_Ogre__Profile_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.set_active_profile

  call-seq:
    set_active_profile(String name)
    set_active_profile(Profile p)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_set_active_profile__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;
  }
  {
    try {
      (arg1)->setActiveProfile((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_set_active_profile__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);
  {
    try {
      (arg1)->setActiveProfile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainMaterialGenerator_set_active_profile(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_set_active_profile__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_set_active_profile__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TerrainMaterialGenerator.set_active_profile", 
    "    void TerrainMaterialGenerator.set_active_profile(Ogre::String const &name)\n"
    "    void TerrainMaterialGenerator.set_active_profile(Ogre::TerrainMaterialGenerator::Profile *p)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.get_active_profile

  call-seq:
    get_active_profile -> Profile

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_get_active_profile(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);
  {
    try {
      result = (Ogre::TerrainMaterialGenerator::Profile *)((Ogre::TerrainMaterialGenerator const *)arg1)->getActiveProfile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainMaterialGenerator__Profile, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator._mark_changed

  call-seq:
    _mark_changed

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator__mark_changed(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);
  {
    try {
      (arg1)->_markChanged();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.get_change_count

  call-seq:
    get_change_count -> unsigned long long

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_get_change_count(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);
  {
    try {
      result = (unsigned long long)((Ogre::TerrainMaterialGenerator const *)arg1)->getChangeCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.get_layer_declaration

  call-seq:
    get_layer_declaration -> TerrainLayerDeclaration

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_get_layer_declaration(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);
  {
    try {
      result = (Ogre::TerrainLayerDeclaration *) &((Ogre::TerrainMaterialGenerator const *)arg1)->getLayerDeclaration();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainLayerDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.can_generate_using_declaration

  call-seq:
    can_generate_using_declaration(TerrainLayerDeclaration decl) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_can_generate_using_declaration(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);
  {
    try {
      result = (bool)(arg1)->canGenerateUsingDeclaration((Ogre::TerrainLayerDeclaration const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.is_vertex_compression_supported

  call-seq:
    is_vertex_compression_supported -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_is_vertex_compression_supported(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);
  {
    try {
      result = (bool)((Ogre::TerrainMaterialGenerator const *)arg1)->isVertexCompressionSupported();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.request_options

  call-seq:
    request_options(Terrain terrain)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_request_options(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);
  {
    try {
      (arg1)->requestOptions(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.generate

  call-seq:
    generate(Terrain terrain) -> MaterialPtr

An instance method.

*/
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);
  {
    try {
      result = (arg1)->generate((Ogre::Terrain const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.generate_for_composite_map

  call-seq:
    generate_for_composite_map(Terrain terrain) -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_generate_for_composite_map(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);
  {
    try {
      result = (arg1)->generateForCompositeMap((Ogre::Terrain const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.get_max_layers

  call-seq:
    get_max_layers(Terrain terrain) -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_get_max_layers(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::TerrainMaterialGenerator const *)arg1)->getMaxLayers((Ogre::Terrain const *)arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.update_composite_map

  call-seq:
    update_composite_map(Terrain terrain, Rect rect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_update_composite_map(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);
  {
    try {
      (arg1)->updateCompositeMap((Ogre::Terrain const *)arg2,(Ogre::Rect const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.update_params

  call-seq:
    update_params(MaterialPtr mat, Terrain terrain)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_update_params(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);
  {
    try {
      (arg1)->updateParams((Ogre::MaterialPtr const &)*arg2,(Ogre::Terrain const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.update_params_for_composite_map

  call-seq:
    update_params_for_composite_map(MaterialPtr mat, Terrain terrain)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_update_params_for_composite_map(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);
  {
    try {
      (arg1)->updateParamsForCompositeMap((Ogre::MaterialPtr const &)*arg2,(Ogre::Terrain const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.set_debug_level

  call-seq:
    set_debug_level(unsigned int dbg)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_set_debug_level(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);
  {
    try {
      (arg1)->setDebugLevel(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator.get_debug_level

  call-seq:
    get_debug_level -> unsigned int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_get_debug_level(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);
  {
    try {
      result = (unsigned int)((Ogre::TerrainMaterialGenerator const *)arg1)->getDebugLevel();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator._render_composite_map

  call-seq:
    _render_composite_map(size_t size, Rect rect, MaterialPtr mat, TexturePtr destCompositeMap)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator__render_composite_map(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);
  {
    try {
      (arg1)->_renderCompositeMap(arg2,(Ogre::Rect const &)*arg3,(Ogre::MaterialPtr const &)*arg4,(Ogre::TexturePtr const &)*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainMaterialGenerator._get_composite_map_rtt

  call-seq:
    _get_composite_map_rtt -> Texture

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator__get_composite_map_rtt(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);
  {
    try {
      result = (Ogre::Texture *)(arg1)->_getCompositeMapRTT();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Texture, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::TerrainMaterialGeneratorA < Ogre::Ogre::TerrainMaterialGenerator

  Proxy of C++ Ogre::TerrainMaterialGeneratorA class


*/
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;
  }
  


/*
  Document-method: Ogre::TerrainMaterialGeneratorA.new

  call-seq:
    TerrainMaterialGeneratorA.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TerrainMaterialGeneratorA *)new Ogre::TerrainMaterialGeneratorA();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainMaterialGeneratorA(Ogre::TerrainMaterialGeneratorA *arg1) {
    delete arg1;
}


/*
  Document-class: Ogre::TerrainPagedWorldSection < Ogre::Ogre::PagedWorldSection

  Proxy of C++ Ogre::TerrainPagedWorldSection class


*/
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;
  }
  


/*
  Document-method: Ogre::TerrainPagedWorldSection.new

  call-seq:
    TerrainPagedWorldSection.new(String name, PagedWorld parent, SceneManager sm)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::TerrainPagedWorldSection *)new Ogre::TerrainPagedWorldSection((Ogre::String const &)*arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}


/*
  Document-method: Ogre::TerrainPagedWorldSection.init

  call-seq:
    init(TerrainGroup grp)

An instance method.

*/
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);
  {
    try {
      (arg1)->init(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.get_terrain_group

  call-seq:
    get_terrain_group -> TerrainGroup

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_get_terrain_group(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);
  {
    try {
      result = (Ogre::TerrainGroup *)(arg1)->getTerrainGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainGroup, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.set_load_radius

  call-seq:
    set_load_radius(Real sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_set_load_radius(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);
  {
    try {
      (arg1)->setLoadRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.get_load_radius

  call-seq:
    get_load_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_get_load_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TerrainPagedWorldSection const *)arg1)->getLoadRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.set_hold_radius

  call-seq:
    set_hold_radius(Real sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_set_hold_radius(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);
  {
    try {
      (arg1)->setHoldRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.get_hold_radius

  call-seq:
    get_hold_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_get_hold_radius(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getHoldRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.set_page_range

  call-seq:
    set_page_range(int32 minX, int32 minY, int32 maxX, int32 maxY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_set_page_range(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);
  {
    try {
      (arg1)->setPageRange(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.set_page_range_min_x

  call-seq:
    set_page_range_min_x(int32 minX)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_set_page_range_min_x(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);
  {
    try {
      (arg1)->setPageRangeMinX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.set_page_range_min_y

  call-seq:
    set_page_range_min_y(int32 minY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_set_page_range_min_y(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);
  {
    try {
      (arg1)->setPageRangeMinY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.set_page_range_max_x

  call-seq:
    set_page_range_max_x(int32 maxX)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_set_page_range_max_x(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);
  {
    try {
      (arg1)->setPageRangeMaxX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.set_page_range_max_y

  call-seq:
    set_page_range_max_y(int32 maxY)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_set_page_range_max_y(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);
  {
    try {
      (arg1)->setPageRangeMaxY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.get_page_range_min_x

  call-seq:
    get_page_range_min_x -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_get_page_range_min_x(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);
  {
    try {
      result = (Ogre::int32)((Ogre::TerrainPagedWorldSection const *)arg1)->getPageRangeMinX();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.get_page_range_min_y

  call-seq:
    get_page_range_min_y -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_get_page_range_min_y(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);
  {
    try {
      result = (Ogre::int32)((Ogre::TerrainPagedWorldSection const *)arg1)->getPageRangeMinY();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.get_page_range_max_x

  call-seq:
    get_page_range_max_x -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_get_page_range_max_x(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);
  {
    try {
      result = (Ogre::int32)((Ogre::TerrainPagedWorldSection const *)arg1)->getPageRangeMaxX();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.get_page_range_max_y

  call-seq:
    get_page_range_max_y -> int32

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_get_page_range_max_y(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);
  {
    try {
      result = (Ogre::int32)((Ogre::TerrainPagedWorldSection const *)arg1)->getPageRangeMaxY();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.get_grid_strategy

  call-seq:
    get_grid_strategy -> Grid2DPageStrategy

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_get_grid_strategy(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);
  {
    try {
      result = (Ogre::Grid2DPageStrategy *)((Ogre::TerrainPagedWorldSection const *)arg1)->getGridStrategy();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Grid2DPageStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.get_grid_strategy_data

  call-seq:
    get_grid_strategy_data -> Grid2DPageStrategyData

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_get_grid_strategy_data(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);
  {
    try {
      result = (Ogre::Grid2DPageStrategyData *)((Ogre::TerrainPagedWorldSection const *)arg1)->getGridStrategyData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Grid2DPageStrategyData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.load_page

  call-seq:
    load_page(PageID pageID, bool forceSynchronous=false)
    load_page(PageID pageID)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_load_page__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);
  {
    try {
      (arg1)->loadPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_load_page__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);
  {
    try {
      (arg1)->loadPage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainPagedWorldSection_load_page(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_load_page__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_load_page__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainPagedWorldSection.load_page", 
    "    void TerrainPagedWorldSection.load_page(Ogre::PageID pageID, bool forceSynchronous)\n"
    "    void TerrainPagedWorldSection.load_page(Ogre::PageID pageID)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::TerrainPagedWorldSection.unload_page

  call-seq:
    unload_page(PageID pageID, bool forceSynchronous=false)
    unload_page(PageID pageID)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_unload_page__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);
  {
    try {
      (arg1)->unloadPage(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_unload_page__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);
  {
    try {
      (arg1)->unloadPage(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainPagedWorldSection_unload_page(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_unload_page__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_unload_page__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainPagedWorldSection.unload_page", 
    "    void TerrainPagedWorldSection.unload_page(Ogre::PageID pageID, bool forceSynchronous)\n"
    "    void TerrainPagedWorldSection.unload_page(Ogre::PageID pageID)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::TerrainPaging

  Proxy of C++ Ogre::TerrainPaging class


*/
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;
  }
  


/*
  Document-method: Ogre::TerrainPaging.new

  call-seq:
    TerrainPaging.new(PageManager pageMgr)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::TerrainPaging *)new Ogre::TerrainPaging(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainPaging(Ogre::TerrainPaging *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::TerrainPaging.create_world_section

  call-seq:
    create_world_section(PagedWorld world, TerrainGroup terrainGroup, Real loadRadius, 
    Real holdRadius, int32 minX=-10, int32 minY=-10, 
    int32 maxX=10, int32 maxY=10, 
    String sectionName=BLANK) -> TerrainPagedWorldSection
    create_world_section(PagedWorld world, TerrainGroup terrainGroup, Real loadRadius, 
    Real holdRadius, int32 minX=-10, int32 minY=-10, 
    int32 maxX=10, int32 maxY=10) -> TerrainPagedWorldSection
    create_world_section(PagedWorld world, TerrainGroup terrainGroup, Real loadRadius, 
    Real holdRadius, int32 minX=-10, int32 minY=-10, 
    int32 maxX=10) -> TerrainPagedWorldSection
    create_world_section(PagedWorld world, TerrainGroup terrainGroup, Real loadRadius, 
    Real holdRadius, int32 minX=-10, int32 minY=-10) -> TerrainPagedWorldSection
    create_world_section(PagedWorld world, TerrainGroup terrainGroup, Real loadRadius, 
    Real holdRadius, int32 minX=-10) -> TerrainPagedWorldSection
    create_world_section(PagedWorld world, TerrainGroup terrainGroup, Real loadRadius, 
    Real holdRadius) -> TerrainPagedWorldSection

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainPaging_create_world_section__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;
  }
  {
    try {
      result = (Ogre::TerrainPagedWorldSection *)(arg1)->createWorldSection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(Ogre::String const &)*arg10);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (SWIG_IsNewObj(res10)) delete arg10;
  return vresult;
fail:
  if (SWIG_IsNewObj(res10)) delete arg10;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPaging_create_world_section__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);
  {
    try {
      result = (Ogre::TerrainPagedWorldSection *)(arg1)->createWorldSection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPaging_create_world_section__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);
  {
    try {
      result = (Ogre::TerrainPagedWorldSection *)(arg1)->createWorldSection(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPaging_create_world_section__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);
  {
    try {
      result = (Ogre::TerrainPagedWorldSection *)(arg1)->createWorldSection(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPaging_create_world_section__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);
  {
    try {
      result = (Ogre::TerrainPagedWorldSection *)(arg1)->createWorldSection(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPaging_create_world_section__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);
  {
    try {
      result = (Ogre::TerrainPagedWorldSection *)(arg1)->createWorldSection(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainPaging_create_world_section(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_create_world_section__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_create_world_section__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_create_world_section__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_create_world_section__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_create_world_section__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_create_world_section__SWIG_0(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 11, "TerrainPaging.create_world_section", 
    "    Ogre::TerrainPagedWorldSection * TerrainPaging.create_world_section(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.create_world_section(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.create_world_section(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.create_world_section(Ogre::PagedWorld *world, Ogre::TerrainGroup *terrainGroup, Ogre::Real loadRadius, Ogre::Real holdRadius, Ogre::int32 minX, Ogre::int32 minY)\n"
    "    Ogre::TerrainPagedWorldSection * TerrainPaging.create_world_section(Ogre::PagedWorld *world, Ogre::TerrainGroup *terrainGroup, Ogre::Real loadRadius, Ogre::Real holdRadius, Ogre::int32 minX)\n"
    "    Ogre::TerrainPagedWorldSection * TerrainPaging.create_world_section(Ogre::PagedWorld *world, Ogre::TerrainGroup *terrainGroup, Ogre::Real loadRadius, Ogre::Real holdRadius)\n");
  
  return Qnil;
}



/*
  Document-class: Ogre::TerrainQuadTreeNode

  Proxy of C++ Ogre::TerrainQuadTreeNode class


*/
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;
  }
  


/*
  Document-method: Ogre::TerrainQuadTreeNode.new

  call-seq:
    TerrainQuadTreeNode.new(Terrain terrain, TerrainQuadTreeNode parent, uint16 xoff, 
    uint16 yoff, uint16 size, uint16 lod, 
    uint16 depth, uint16 quadrant)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::TerrainQuadTreeNode *)new Ogre::TerrainQuadTreeNode(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainQuadTreeNode(Ogre::TerrainQuadTreeNode *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::TerrainQuadTreeNode.get_xoffset

  call-seq:
    get_xoffset -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_xoffset(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::TerrainQuadTreeNode const *)arg1)->getXOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_yoffset

  call-seq:
    get_yoffset -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_yoffset(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::TerrainQuadTreeNode const *)arg1)->getYOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.is_leaf

  call-seq:
    is_leaf -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_is_leaf(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);
  {
    try {
      result = (bool)((Ogre::TerrainQuadTreeNode const *)arg1)->isLeaf();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_base_lod

  call-seq:
    get_base_lod -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_base_lod(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::TerrainQuadTreeNode const *)arg1)->getBaseLod();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_lod_count

  call-seq:
    get_lod_count -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_lod_count(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::TerrainQuadTreeNode const *)arg1)->getLodCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_child

  call-seq:
    get_child(unsigned short child) -> TerrainQuadTreeNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_child(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);
  {
    try {
      result = (Ogre::TerrainQuadTreeNode *)((Ogre::TerrainQuadTreeNode const *)arg1)->getChild(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainQuadTreeNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_parent

  call-seq:
    get_parent -> TerrainQuadTreeNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_parent(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);
  {
    try {
      result = (Ogre::TerrainQuadTreeNode *)((Ogre::TerrainQuadTreeNode const *)arg1)->getParent();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainQuadTreeNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_terrain

  call-seq:
    get_terrain -> Terrain

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_terrain(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);
  {
    try {
      result = (Ogre::Terrain *)((Ogre::TerrainQuadTreeNode const *)arg1)->getTerrain();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.prepare

  call-seq:
    prepare
    prepare(StreamSerialiser stream)

An instance method.

*/
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);
  {
    try {
      (arg1)->prepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->prepare(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.load

  call-seq:
    load

An instance method.

*/
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);
  {
    try {
      (arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.unprepare

  call-seq:
    unprepare

An instance method.

*/
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);
  {
    try {
      (arg1)->unprepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.save

  call-seq:
    save(StreamSerialiser stream)

An instance method.

*/
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);
  {
    try {
      (arg1)->save(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_lod_level

  call-seq:
    get_lod_level(uint16 lod) -> LodLevel

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_lod_level(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);
  {
    try {
      result = (Ogre::TerrainQuadTreeNode::LodLevel *)(arg1)->getLodLevel(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainQuadTreeNode__LodLevel, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.pre_delta_calculation

  call-seq:
    pre_delta_calculation(Rect rect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_pre_delta_calculation(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);
  {
    try {
      (arg1)->preDeltaCalculation((Ogre::Rect const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.notify_delta

  call-seq:
    notify_delta(uint16 x, uint16 y, uint16 lod, Real delta)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_notify_delta(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);
  {
    try {
      (arg1)->notifyDelta(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.post_delta_calculation

  call-seq:
    post_delta_calculation(Rect rect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_post_delta_calculation(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);
  {
    try {
      (arg1)->postDeltaCalculation((Ogre::Rect const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.finalise_delta_values

  call-seq:
    finalise_delta_values(Rect rect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_finalise_delta_values(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);
  {
    try {
      (arg1)->finaliseDeltaValues((Ogre::Rect const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.assign_vertex_data

  call-seq:
    assign_vertex_data(uint16 treeDepthStart, uint16 treeDepthEnd, uint16 resolution, 
    uint sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_assign_vertex_data(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);
  {
    try {
      (arg1)->assignVertexData(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.use_ancestor_vertex_data

  call-seq:
    use_ancestor_vertex_data(TerrainQuadTreeNode owner, uint16 treeDepthEnd, uint16 resolution)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_use_ancestor_vertex_data(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);
  {
    try {
      (arg1)->useAncestorVertexData(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.update_vertex_data

  call-seq:
    update_vertex_data(bool positions, bool deltas, Rect rect, bool cpuData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_update_vertex_data(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);
  {
    try {
      (arg1)->updateVertexData(arg2,arg3,(Ogre::Rect const &)*arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.merge_into_bounds

  call-seq:
    merge_into_bounds(long x, long y, Vector3 pos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_merge_into_bounds(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);
  {
    try {
      (arg1)->mergeIntoBounds(arg2,arg3,(Ogre::Vector3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.reset_bounds

  call-seq:
    reset_bounds(Rect rect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_reset_bounds(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);
  {
    try {
      (arg1)->resetBounds((Ogre::Rect const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.rect_intersects_node

  call-seq:
    rect_intersects_node(Rect rect) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_rect_intersects_node(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);
  {
    try {
      result = (bool)(arg1)->rectIntersectsNode((Ogre::Rect const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.rect_contains_node

  call-seq:
    rect_contains_node(Rect rect) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_rect_contains_node(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);
  {
    try {
      result = (bool)(arg1)->rectContainsNode((Ogre::Rect const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.point_intersects_node

  call-seq:
    point_intersects_node(long x, long y) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_point_intersects_node(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);
  {
    try {
      result = (bool)(arg1)->pointIntersectsNode(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_aabb

  call-seq:
    get_aabb -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_aabb(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::TerrainQuadTreeNode const *)arg1)->getAABB();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TerrainQuadTreeNode const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_local_centre

  call-seq:
    get_local_centre -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_local_centre(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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::TerrainQuadTreeNode const *)arg1)->getLocalCentre();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_min_height

  call-seq:
    get_min_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_min_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TerrainQuadTreeNode const *)arg1)->getMinHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_max_height

  call-seq:
    get_max_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_max_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::TerrainQuadTreeNode const *)arg1)->getMaxHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.calculate_current_lod

  call-seq:
    calculate_current_lod(Camera cam, Real cFactor) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_calculate_current_lod(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);
  {
    try {
      result = (bool)(arg1)->calculateCurrentLod((Ogre::Camera const *)arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_current_lod

  call-seq:
    get_current_lod -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_current_lod(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);
  {
    try {
      result = (int)((Ogre::TerrainQuadTreeNode const *)arg1)->getCurrentLod();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.is_rendered_at_current_lod

  call-seq:
    is_rendered_at_current_lod -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_is_rendered_at_current_lod(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);
  {
    try {
      result = (bool)((Ogre::TerrainQuadTreeNode const *)arg1)->isRenderedAtCurrentLod();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.is_self_or_child_rendered_at_current_lod

  call-seq:
    is_self_or_child_rendered_at_current_lod -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_is_self_or_child_rendered_at_current_lod(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);
  {
    try {
      result = (bool)((Ogre::TerrainQuadTreeNode const *)arg1)->isSelfOrChildRenderedAtCurrentLod();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.set_current_lod

  call-seq:
    set_current_lod(int lod)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_set_current_lod(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);
  {
    try {
      (arg1)->setCurrentLod(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.get_lod_transition

  call-seq:
    get_lod_transition -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_get_lod_transition(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);
  {
    try {
      result = (float)((Ogre::TerrainQuadTreeNode const *)arg1)->getLodTransition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.set_lod_transition

  call-seq:
    set_lod_transition(float t)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_set_lod_transition(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);
  {
    try {
      (arg1)->setLodTransition(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.POSITION_BUFFER

  call-seq:
    POSITION_BUFFER -> unsigned short

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainQuadTreeNode.POSITION_BUFFER=

  call-seq:
    POSITION_BUFFER=(x) -> unsigned short

Set new value for attribute.

*/

/*
  Document-method: Ogre::TerrainQuadTreeNode.TerrainQuadTreeNode_POSITION_BUFFER

  call-seq:
    TerrainQuadTreeNode_POSITION_BUFFER -> unsigned short

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.TerrainQuadTreeNode_POSITION_BUFFER=

  call-seq:
    TerrainQuadTreeNode_POSITION_BUFFER=(x) -> unsigned short

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.DELTA_BUFFER

  call-seq:
    DELTA_BUFFER -> unsigned short

Get value of attribute.

*/

/*
  Document-method: Ogre::TerrainQuadTreeNode.DELTA_BUFFER=

  call-seq:
    DELTA_BUFFER=(x) -> unsigned short

Set new value for attribute.

*/

/*
  Document-method: Ogre::TerrainQuadTreeNode.TerrainQuadTreeNode_DELTA_BUFFER

  call-seq:
    TerrainQuadTreeNode_DELTA_BUFFER -> unsigned short

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode.TerrainQuadTreeNode_DELTA_BUFFER=

  call-seq:
    TerrainQuadTreeNode_DELTA_BUFFER=(x) -> unsigned short

Set new value for attribute.

*/
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;
}



/*
  Document-method: Ogre::TerrainQuadTreeNode._get_renderable

  call-seq:
    _get_renderable -> Renderable

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode__get_renderable(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);
  {
    try {
      result = (Ogre::Renderable *)(arg1)->_getRenderable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::Terrain

  Proxy of C++ Ogre::Terrain class


*/
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;
  }
  


/*
  Document-method: Ogre::Terrain.new

  call-seq:
    Terrain.new(SceneManager sm)

Class constructor.

*/
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);
  {
    try {
      result = (Ogre::Terrain *)new Ogre::Terrain(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Terrain(Ogre::Terrain *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Terrain.TERRAIN_CHUNK_ID

  call-seq:
    TERRAIN_CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAIN_CHUNK_ID

  call-seq:
    Terrain_TERRAIN_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.TERRAIN_CHUNK_VERSION

  call-seq:
    TERRAIN_CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAIN_CHUNK_VERSION

  call-seq:
    Terrain_TERRAIN_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.TERRAIN_MAX_BATCH_SIZE

  call-seq:
    TERRAIN_MAX_BATCH_SIZE -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAIN_MAX_BATCH_SIZE

  call-seq:
    Terrain_TERRAIN_MAX_BATCH_SIZE -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.TERRAINLAYERDECLARATION_CHUNK_ID

  call-seq:
    TERRAINLAYERDECLARATION_CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAINLAYERDECLARATION_CHUNK_ID

  call-seq:
    Terrain_TERRAINLAYERDECLARATION_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.TERRAINLAYERDECLARATION_CHUNK_VERSION

  call-seq:
    TERRAINLAYERDECLARATION_CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAINLAYERDECLARATION_CHUNK_VERSION

  call-seq:
    Terrain_TERRAINLAYERDECLARATION_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.TERRAINLAYERSAMPLER_CHUNK_ID

  call-seq:
    TERRAINLAYERSAMPLER_CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAINLAYERSAMPLER_CHUNK_ID

  call-seq:
    Terrain_TERRAINLAYERSAMPLER_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.TERRAINLAYERSAMPLER_CHUNK_VERSION

  call-seq:
    TERRAINLAYERSAMPLER_CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAINLAYERSAMPLER_CHUNK_VERSION

  call-seq:
    Terrain_TERRAINLAYERSAMPLER_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.TERRAINLAYERSAMPLERELEMENT_CHUNK_ID

  call-seq:
    TERRAINLAYERSAMPLERELEMENT_CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAINLAYERSAMPLERELEMENT_CHUNK_ID

  call-seq:
    Terrain_TERRAINLAYERSAMPLERELEMENT_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.TERRAINLAYERSAMPLERELEMENT_CHUNK_VERSION

  call-seq:
    TERRAINLAYERSAMPLERELEMENT_CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAINLAYERSAMPLERELEMENT_CHUNK_VERSION

  call-seq:
    Terrain_TERRAINLAYERSAMPLERELEMENT_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.TERRAINLAYERINSTANCE_CHUNK_ID

  call-seq:
    TERRAINLAYERINSTANCE_CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAINLAYERINSTANCE_CHUNK_ID

  call-seq:
    Terrain_TERRAINLAYERINSTANCE_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.TERRAINLAYERINSTANCE_CHUNK_VERSION

  call-seq:
    TERRAINLAYERINSTANCE_CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAINLAYERINSTANCE_CHUNK_VERSION

  call-seq:
    Terrain_TERRAINLAYERINSTANCE_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.TERRAINDERIVEDDATA_CHUNK_ID

  call-seq:
    TERRAINDERIVEDDATA_CHUNK_ID -> uint32

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAINDERIVEDDATA_CHUNK_ID

  call-seq:
    Terrain_TERRAINDERIVEDDATA_CHUNK_ID -> uint32

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.TERRAINDERIVEDDATA_CHUNK_VERSION

  call-seq:
    TERRAINDERIVEDDATA_CHUNK_VERSION -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_TERRAINDERIVEDDATA_CHUNK_VERSION

  call-seq:
    Terrain_TERRAINDERIVEDDATA_CHUNK_VERSION -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.LOD_MORPH_CUSTOM_PARAM

  call-seq:
    LOD_MORPH_CUSTOM_PARAM -> size_t

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_LOD_MORPH_CUSTOM_PARAM

  call-seq:
    Terrain_LOD_MORPH_CUSTOM_PARAM -> size_t

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Alignment.ALIGN_X_Z

  call-seq:
    ALIGN_X_Z -> int

A class method.

*/

/*
  Document-method: Ogre::Alignment.ALIGN_X_Y

  call-seq:
    ALIGN_X_Y -> int

A class method.

*/

/*
  Document-method: Ogre::Alignment.ALIGN_Y_Z

  call-seq:
    ALIGN_Y_Z -> int

A class method.

*/

/*
  Document-method: Ogre::NeighbourIndex.NEIGHBOUR_EAST

  call-seq:
    NEIGHBOUR_EAST -> int

A class method.

*/

/*
  Document-method: Ogre::NeighbourIndex.NEIGHBOUR_NORTHEAST

  call-seq:
    NEIGHBOUR_NORTHEAST -> int

A class method.

*/

/*
  Document-method: Ogre::NeighbourIndex.NEIGHBOUR_NORTH

  call-seq:
    NEIGHBOUR_NORTH -> int

A class method.

*/

/*
  Document-method: Ogre::NeighbourIndex.NEIGHBOUR_NORTHWEST

  call-seq:
    NEIGHBOUR_NORTHWEST -> int

A class method.

*/

/*
  Document-method: Ogre::NeighbourIndex.NEIGHBOUR_WEST

  call-seq:
    NEIGHBOUR_WEST -> int

A class method.

*/

/*
  Document-method: Ogre::NeighbourIndex.NEIGHBOUR_SOUTHWEST

  call-seq:
    NEIGHBOUR_SOUTHWEST -> int

A class method.

*/

/*
  Document-method: Ogre::NeighbourIndex.NEIGHBOUR_SOUTH

  call-seq:
    NEIGHBOUR_SOUTH -> int

A class method.

*/

/*
  Document-method: Ogre::NeighbourIndex.NEIGHBOUR_SOUTHEAST

  call-seq:
    NEIGHBOUR_SOUTHEAST -> int

A class method.

*/

/*
  Document-method: Ogre::NeighbourIndex.NEIGHBOUR_COUNT

  call-seq:
    NEIGHBOUR_COUNT -> int

A class method.

*/

/*
  Document-method: Ogre::Terrain.get_scene_manager

  call-seq:
    get_scene_manager -> SceneManager

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_scene_manager(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);
  {
    try {
      result = (Ogre::SceneManager *)((Ogre::Terrain const *)arg1)->getSceneManager();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Space.WORLD_SPACE

  call-seq:
    WORLD_SPACE -> int

A class method.

*/

/*
  Document-method: Ogre::Space.LOCAL_SPACE

  call-seq:
    LOCAL_SPACE -> int

A class method.

*/

/*
  Document-method: Ogre::Space.TERRAIN_SPACE

  call-seq:
    TERRAIN_SPACE -> int

A class method.

*/

/*
  Document-method: Ogre::Space.POINT_SPACE

  call-seq:
    POINT_SPACE -> int

A class method.

*/

/*
  Document-method: Ogre::Terrain.set_gpu_buffer_allocator

  call-seq:
    set_gpu_buffer_allocator(GpuBufferAllocator alloc)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_gpu_buffer_allocator(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);
  {
    try {
      (arg1)->setGpuBufferAllocator(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_gpu_buffer_allocator

  call-seq:
    get_gpu_buffer_allocator -> GpuBufferAllocator

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_gpu_buffer_allocator(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);
  {
    try {
      result = (Ogre::Terrain::GpuBufferAllocator *)(arg1)->getGpuBufferAllocator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain__GpuBufferAllocator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._get_num_indexes_for_batch_size

  call-seq:
    _get_num_indexes_for_batch_size(uint16 batchSize) -> size_t

A class method.

*/
SWIGINTERN VALUE
_wrap_Terrain__get_num_indexes_for_batch_size(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);
  {
    try {
      result = Ogre::Terrain::_getNumIndexesForBatchSize(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._populate_index_buffer

  call-seq:
    _populate_index_buffer(uint16 pIndexes, uint16 batchSize, uint16 vdatasize, 
    size_t vertexIncrement, uint16 xoffset, uint16 yoffset, 
    uint16 numSkirtRowsCols, uint16 skirtRowColSkip)

A class method.

*/
SWIGINTERN VALUE
_wrap_Terrain__populate_index_buffer(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);
  {
    try {
      Ogre::Terrain::_populateIndexBuffer(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._calc_skirt_vertex_index

  call-seq:
    _calc_skirt_vertex_index(uint16 mainIndex, uint16 vdatasize, bool isCol, uint16 numSkirtRowsCols, 
    uint16 skirtRowColSkip) -> uint16

A class method.

*/
SWIGINTERN VALUE
_wrap_Terrain__calc_skirt_vertex_index(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);
  {
    try {
      result = (Ogre::uint16)Ogre::Terrain::_calcSkirtVertexIndex(arg1,arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.convert_position

  call-seq:
    convert_position(Space inSpace, Vector3 inPos, Space outSpace, Vector3 outPos)
    convert_position(Space inSpace, Vector3 inPos, Space outSpace) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_convert_position__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);
  {
    try {
      ((Ogre::Terrain const *)arg1)->convertPosition(arg2,(Ogre::Vector3 const &)*arg3,arg4,*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_convert_position__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);
  {
    try {
      result = ((Ogre::Terrain const *)arg1)->convertPosition(arg2,(Ogre::Vector3 const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_convert_position(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_convert_position__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_convert_position__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.convert_position", 
    "    Ogre::Vector3 Terrain.convert_position(Ogre::Terrain::Space inSpace, Ogre::Vector3 const &inPos, Ogre::Terrain::Space outSpace, Ogre::Vector3 &outPos)\n"
    "    Ogre::Vector3 Terrain.convert_position(Ogre::Terrain::Space inSpace, Ogre::Vector3 const &inPos, Ogre::Terrain::Space outSpace)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.convert_direction

  call-seq:
    convert_direction(Space inSpace, Vector3 inDir, Space outSpace, Vector3 outDir)
    convert_direction(Space inSpace, Vector3 inDir, Space outSpace) -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_convert_direction__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);
  {
    try {
      ((Ogre::Terrain const *)arg1)->convertDirection(arg2,(Ogre::Vector3 const &)*arg3,arg4,*arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_convert_direction__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);
  {
    try {
      result = ((Ogre::Terrain const *)arg1)->convertDirection(arg2,(Ogre::Vector3 const &)*arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_convert_direction(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_convert_direction__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_convert_direction__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.convert_direction", 
    "    Ogre::Vector3 Terrain.convert_direction(Ogre::Terrain::Space inSpace, Ogre::Vector3 const &inDir, Ogre::Terrain::Space outSpace, Ogre::Vector3 &outDir)\n"
    "    Ogre::Vector3 Terrain.convert_direction(Ogre::Terrain::Space inSpace, Ogre::Vector3 const &inDir, Ogre::Terrain::Space outSpace)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.set_resource_group

  call-seq:
    set_resource_group(String resGroup)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_resource_group(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;
  }
  {
    try {
      (arg1)->setResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_resource_group

  call-seq:
    get_resource_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_resource_group(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Terrain const *)arg1)->getResourceGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._get_derived_resource_group

  call-seq:
    _get_derived_resource_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain__get_derived_resource_group(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Terrain const *)arg1)->_getDerivedResourceGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.save

  call-seq:
    save(String filename)
    save(StreamSerialiser stream)

An instance method.

*/
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;
  }
  {
    try {
      (arg1)->save((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->save(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Terrain.prepare

  call-seq:
    prepare(String filename) -> bool
    prepare(StreamSerialiser stream) -> bool
    prepare(ImportData importData) -> bool

An instance method.

*/
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;
  }
  {
    try {
      result = (bool)(arg1)->prepare((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_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);
  {
    try {
      result = (bool)(arg1)->prepare(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      result = (bool)(arg1)->prepare((ImportData const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Terrain.load

  call-seq:
    load(String filename)
    load(StreamSerialiser stream)
    load

An instance method.

*/
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;
  }
  {
    try {
      (arg1)->load((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN 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);
  {
    try {
      (arg1)->load(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->load();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Terrain.is_loaded

  call-seq:
    is_loaded -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_is_loaded(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);
  {
    try {
      result = (bool)((Ogre::Terrain const *)arg1)->isLoaded();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.is_modified

  call-seq:
    is_modified -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_is_modified(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);
  {
    try {
      result = (bool)((Ogre::Terrain const *)arg1)->isModified();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.is_height_data_modified

  call-seq:
    is_height_data_modified -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_is_height_data_modified(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);
  {
    try {
      result = (bool)((Ogre::Terrain const *)arg1)->isHeightDataModified();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.unload

  call-seq:
    unload

An instance method.

*/
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);
  {
    try {
      (arg1)->unload();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.unprepare

  call-seq:
    unprepare

An instance method.

*/
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);
  {
    try {
      (arg1)->unprepare();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_height_data

  call-seq:
    get_height_data -> float
    get_height_data(long x, long y) -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_height_data__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);
  {
    try {
      result = (float *)((Ogre::Terrain const *)arg1)->getHeightData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_get_height_data__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);
  {
    try {
      result = (float *)((Ogre::Terrain const *)arg1)->getHeightData(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_height_data(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_get_height_data__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_get_height_data__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain.get_height_data", 
    "    float * Terrain.get_height_data()\n"
    "    float * Terrain.get_height_data(long x, long y)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_height_at_point

  call-seq:
    get_height_at_point(long x, long y) -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_height_at_point(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);
  {
    try {
      result = (float)((Ogre::Terrain const *)arg1)->getHeightAtPoint(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.set_height_at_point

  call-seq:
    set_height_at_point(long x, long y, float h)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_height_at_point(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);
  {
    try {
      (arg1)->setHeightAtPoint(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_height_at_terrain_position

  call-seq:
    get_height_at_terrain_position(Real x, Real y) -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_height_at_terrain_position(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);
  {
    try {
      result = (float)(arg1)->getHeightAtTerrainPosition(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_height_at_world_position

  call-seq:
    get_height_at_world_position(Real x, Real y, Real z) -> float
    get_height_at_world_position(Vector3 pos) -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_height_at_world_position__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);
  {
    try {
      result = (float)(arg1)->getHeightAtWorldPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_get_height_at_world_position__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);
  {
    try {
      result = (float)(arg1)->getHeightAtWorldPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_height_at_world_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__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_get_height_at_world_position__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_get_height_at_world_position__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Terrain.get_height_at_world_position", 
    "    float Terrain.get_height_at_world_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    float Terrain.get_height_at_world_position(Ogre::Vector3 const &pos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_delta_data

  call-seq:
    get_delta_data -> float
    get_delta_data(long x, long y) -> float

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_delta_data__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);
  {
    try {
      result = (float *)(arg1)->getDeltaData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_get_delta_data__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);
  {
    try {
      result = (float *)(arg1)->getDeltaData(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_delta_data(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_get_delta_data__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_get_delta_data__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain.get_delta_data", 
    "    float const * Terrain.get_delta_data()\n"
    "    float const * Terrain.get_delta_data(long x, long y)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_point

  call-seq:
    get_point(long x, long y, Vector3 outpos)
    get_point(long x, long y, float height, Vector3 outpos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_point__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);
  {
    try {
      (arg1)->getPoint(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_point_from_self_or_neighbour

  call-seq:
    get_point_from_self_or_neighbour(long x, long y, Vector3 outpos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_point_from_self_or_neighbour(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);
  {
    try {
      (arg1)->getPointFromSelfOrNeighbour(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_point

  call-seq:
    get_point(long x, long y, Vector3 outpos)
    get_point(long x, long y, float height, Vector3 outpos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_point__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);
  {
    try {
      (arg1)->getPoint(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 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_get_point__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_get_point__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.get_point", 
    "    void Terrain.get_point(long x, long y, Ogre::Vector3 *outpos)\n"
    "    void Terrain.get_point(long x, long y, float height, Ogre::Vector3 *outpos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_point_transform

  call-seq:
    get_point_transform(Matrix4 outXform)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_point_transform(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);
  {
    try {
      ((Ogre::Terrain const *)arg1)->getPointTransform(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_terrain_vector

  call-seq:
    get_terrain_vector(Vector3 inVec, Vector3 outVec)
    get_terrain_vector(Real x, Real y, Real z, Vector3 outVec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_terrain_vector__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);
  {
    try {
      (arg1)->getTerrainVector((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_terrain_vector_align

  call-seq:
    get_terrain_vector_align(Vector3 inVec, Alignment align, Vector3 outVec)
    get_terrain_vector_align(Real x, Real y, Real z, Alignment align, Vector3 outVec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_terrain_vector_align__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);
  {
    try {
      (arg1)->getTerrainVectorAlign((Ogre::Vector3 const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_terrain_vector

  call-seq:
    get_terrain_vector(Vector3 inVec, Vector3 outVec)
    get_terrain_vector(Real x, Real y, Real z, Vector3 outVec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_terrain_vector__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);
  {
    try {
      (arg1)->getTerrainVector(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_terrain_vector(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_get_terrain_vector__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_get_terrain_vector__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.get_terrain_vector", 
    "    void Terrain.get_terrain_vector(Ogre::Vector3 const &inVec, Ogre::Vector3 *outVec)\n"
    "    void Terrain.get_terrain_vector(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Vector3 *outVec)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_terrain_vector_align

  call-seq:
    get_terrain_vector_align(Vector3 inVec, Alignment align, Vector3 outVec)
    get_terrain_vector_align(Real x, Real y, Real z, Alignment align, Vector3 outVec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_terrain_vector_align__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);
  {
    try {
      (arg1)->getTerrainVectorAlign(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_terrain_vector_align(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_get_terrain_vector_align__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_get_terrain_vector_align__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Terrain.get_terrain_vector_align", 
    "    void Terrain.get_terrain_vector_align(Ogre::Vector3 const &inVec, Ogre::Terrain::Alignment align, Ogre::Vector3 *outVec)\n"
    "    void Terrain.get_terrain_vector_align(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Terrain::Alignment align, Ogre::Vector3 *outVec)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_vector

  call-seq:
    get_vector(Vector3 inVec, Vector3 outVec)
    get_vector(Real x, Real y, Real z, Vector3 outVec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_vector__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);
  {
    try {
      (arg1)->getVector((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_vector_align

  call-seq:
    get_vector_align(Vector3 inVec, Alignment align, Vector3 outVec)
    get_vector_align(Real x, Real y, Real z, Alignment align, Vector3 outVec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_vector_align__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);
  {
    try {
      (arg1)->getVectorAlign((Ogre::Vector3 const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_vector

  call-seq:
    get_vector(Vector3 inVec, Vector3 outVec)
    get_vector(Real x, Real y, Real z, Vector3 outVec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_vector__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);
  {
    try {
      (arg1)->getVector(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_vector(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_get_vector__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_get_vector__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.get_vector", 
    "    void Terrain.get_vector(Ogre::Vector3 const &inVec, Ogre::Vector3 *outVec)\n"
    "    void Terrain.get_vector(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Vector3 *outVec)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_vector_align

  call-seq:
    get_vector_align(Vector3 inVec, Alignment align, Vector3 outVec)
    get_vector_align(Real x, Real y, Real z, Alignment align, Vector3 outVec)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_vector_align__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);
  {
    try {
      (arg1)->getVectorAlign(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_vector_align(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_get_vector_align__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_get_vector_align__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Terrain.get_vector_align", 
    "    void Terrain.get_vector_align(Ogre::Vector3 const &inVec, Ogre::Terrain::Alignment align, Ogre::Vector3 *outVec)\n"
    "    void Terrain.get_vector_align(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Terrain::Alignment align, Ogre::Vector3 *outVec)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_position

  call-seq:
    get_position(Vector3 TSpos, Vector3 outWSpos)
    get_position(Real x, Real y, Real z, Vector3 outWSpos)
    get_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_position__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);
  {
    try {
      (arg1)->getPosition((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_get_position__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);
  {
    try {
      (arg1)->getPosition(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_terrain_position

  call-seq:
    get_terrain_position(Vector3 WSpos, Vector3 outTSpos)
    get_terrain_position(Real x, Real y, Real z, Vector3 outTSpos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_terrain_position__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);
  {
    try {
      (arg1)->getTerrainPosition((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_get_terrain_position__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);
  {
    try {
      (arg1)->getTerrainPosition(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_terrain_position(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_get_terrain_position__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_get_terrain_position__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.get_terrain_position", 
    "    void Terrain.get_terrain_position(Ogre::Vector3 const &WSpos, Ogre::Vector3 *outTSpos)\n"
    "    void Terrain.get_terrain_position(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Vector3 *outTSpos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_position_align

  call-seq:
    get_position_align(Vector3 TSpos, Alignment align, Vector3 outWSpos)
    get_position_align(Real x, Real y, Real z, Alignment align, Vector3 outWSpos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_position_align__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);
  {
    try {
      (arg1)->getPositionAlign((Ogre::Vector3 const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_get_position_align__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);
  {
    try {
      (arg1)->getPositionAlign(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_position_align(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_get_position_align__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_get_position_align__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Terrain.get_position_align", 
    "    void Terrain.get_position_align(Ogre::Vector3 const &TSpos, Ogre::Terrain::Alignment align, Ogre::Vector3 *outWSpos)\n"
    "    void Terrain.get_position_align(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Terrain::Alignment align, Ogre::Vector3 *outWSpos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_terrain_position_align

  call-seq:
    get_terrain_position_align(Vector3 WSpos, Alignment align, Vector3 outTSpos)
    get_terrain_position_align(Real x, Real y, Real z, Alignment align, Vector3 outTSpos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_terrain_position_align__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);
  {
    try {
      (arg1)->getTerrainPositionAlign((Ogre::Vector3 const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_get_terrain_position_align__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);
  {
    try {
      (arg1)->getTerrainPositionAlign(arg2,arg3,arg4,arg5,arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_terrain_position_align(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_get_terrain_position_align__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_get_terrain_position_align__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Terrain.get_terrain_position_align", 
    "    void Terrain.get_terrain_position_align(Ogre::Vector3 const &WSpos, Ogre::Terrain::Alignment align, Ogre::Vector3 *outTSpos)\n"
    "    void Terrain.get_terrain_position_align(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Terrain::Alignment align, Ogre::Vector3 *outTSpos)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_alignment

  call-seq:
    get_alignment -> int

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_alignment(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);
  {
    try {
      result = (Ogre::Terrain::Alignment)((Ogre::Terrain const *)arg1)->getAlignment();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_size

  call-seq:
    get_size -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_size(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.set_size

  call-seq:
    set_size(uint16 newSize)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_size(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);
  {
    try {
      (arg1)->setSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_max_batch_size

  call-seq:
    get_max_batch_size -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_max_batch_size(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getMaxBatchSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_min_batch_size

  call-seq:
    get_min_batch_size -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_min_batch_size(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getMinBatchSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_world_size

  call-seq:
    get_world_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_world_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getWorldSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.set_world_size

  call-seq:
    set_world_size(Real newWorldSize)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_world_size(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);
  {
    try {
      (arg1)->setWorldSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_layer_count

  call-seq:
    get_layer_count -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_layer_count(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::Terrain const *)arg1)->getLayerCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_layer_declaration

  call-seq:
    get_layer_declaration -> TerrainLayerDeclaration

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_layer_declaration(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);
  {
    try {
      result = (Ogre::TerrainLayerDeclaration *) &((Ogre::Terrain const *)arg1)->getLayerDeclaration();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainLayerDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.add_layer

  call-seq:
    add_layer(Real worldSize=0, StringVector textureNames=0)
    add_layer(Real worldSize=0)
    add_layer
    add_layer(uint8 index, Real worldSize=0, StringVector textureNames=0)
    add_layer(uint8 index, Real worldSize=0)
    add_layer(uint8 index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_add_layer__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);
  {
    try {
      (arg1)->addLayer(arg2,(Ogre::StringVector const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_add_layer__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);
  {
    try {
      (arg1)->addLayer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_add_layer__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);
  {
    try {
      (arg1)->addLayer();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_add_layer__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);
  {
    try {
      (arg1)->addLayer(arg2,arg3,(Ogre::StringVector const *)arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_add_layer__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);
  {
    try {
      (arg1)->addLayer(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_add_layer__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);
  {
    try {
      (arg1)->addLayer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_add_layer(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_add_layer__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_add_layer__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_add_layer__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_add_layer__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_add_layer__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_add_layer__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Terrain.add_layer", 
    "    void Terrain.add_layer(Ogre::Real worldSize, Ogre::StringVector const *textureNames)\n"
    "    void Terrain.add_layer(Ogre::Real worldSize)\n"
    "    void Terrain.add_layer()\n"
    "    void Terrain.add_layer(Ogre::uint8 index, Ogre::Real worldSize, Ogre::StringVector const *textureNames)\n"
    "    void Terrain.add_layer(Ogre::uint8 index, Ogre::Real worldSize)\n"
    "    void Terrain.add_layer(Ogre::uint8 index)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.remove_layer

  call-seq:
    remove_layer(uint8 index)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_remove_layer(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);
  {
    try {
      (arg1)->removeLayer(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.replace_layer

  call-seq:
    replace_layer(uint8 index, bool keepBlends, Real worldSize=0, StringVector textureNames=0)
    replace_layer(uint8 index, bool keepBlends, Real worldSize=0)
    replace_layer(uint8 index, bool keepBlends)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_replace_layer__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);
  {
    try {
      (arg1)->replaceLayer(arg2,arg3,arg4,(Ogre::StringVector const *)arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_replace_layer__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);
  {
    try {
      (arg1)->replaceLayer(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_replace_layer__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);
  {
    try {
      (arg1)->replaceLayer(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_replace_layer(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_replace_layer__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_replace_layer__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_replace_layer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.replace_layer", 
    "    void Terrain.replace_layer(Ogre::uint8 index, bool keepBlends, Ogre::Real worldSize, Ogre::StringVector const *textureNames)\n"
    "    void Terrain.replace_layer(Ogre::uint8 index, bool keepBlends, Ogre::Real worldSize)\n"
    "    void Terrain.replace_layer(Ogre::uint8 index, bool keepBlends)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_max_layers

  call-seq:
    get_max_layers -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_max_layers(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::Terrain const *)arg1)->getMaxLayers();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_layer_world_size

  call-seq:
    get_layer_world_size(uint8 index) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_layer_world_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getLayerWorldSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.set_layer_world_size

  call-seq:
    set_layer_world_size(uint8 index, Real size)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_layer_world_size(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);
  {
    try {
      (arg1)->setLayerWorldSize(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_layer_uvmultiplier

  call-seq:
    get_layer_uvmultiplier(uint8 index) -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_layer_uvmultiplier(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getLayerUVMultiplier(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_layer_texture_name

  call-seq:
    get_layer_texture_name(uint8 layerIndex, uint8 samplerIndex) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_layer_texture_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Terrain const *)arg1)->getLayerTextureName(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.set_layer_texture_name

  call-seq:
    set_layer_texture_name(uint8 layerIndex, uint8 samplerIndex, String textureName)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_layer_texture_name(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;
  }
  {
    try {
      (arg1)->setLayerTextureName(arg2,arg3,(Ogre::String const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_layer_blend_map_size

  call-seq:
    get_layer_blend_map_size -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_layer_blend_map_size(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getLayerBlendMapSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_lightmap_size

  call-seq:
    get_lightmap_size -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_lightmap_size(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getLightmapSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_lightmap

  call-seq:
    get_lightmap -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_lightmap(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);
  {
    try {
      result = (Ogre::TexturePtr *) &((Ogre::Terrain const *)arg1)->getLightmap();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_composite_map_size

  call-seq:
    get_composite_map_size -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_composite_map_size(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getCompositeMapSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_composite_map

  call-seq:
    get_composite_map -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_composite_map(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);
  {
    try {
      result = (Ogre::TexturePtr *) &((Ogre::Terrain const *)arg1)->getCompositeMap();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_position

  call-seq:
    get_position(Vector3 TSpos, Vector3 outWSpos)
    get_position(Real x, Real y, Real z, Vector3 outWSpos)
    get_position -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_position__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);
  {
    try {
      result = (Ogre::Vector3 *) &((Ogre::Terrain const *)arg1)->getPosition();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_position(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_get_position__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_get_position__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_get_position__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.get_position", 
    "    Ogre::Vector3 const & Terrain.get_position(Ogre::Vector3 const &TSpos, Ogre::Vector3 *outWSpos)\n"
    "    Ogre::Vector3 const & Terrain.get_position(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Vector3 *outWSpos)\n"
    "    Ogre::Vector3 const & Terrain.get_position()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.set_position

  call-seq:
    set_position(Vector3 pos)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_position(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);
  {
    try {
      (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._get_root_scene_node

  call-seq:
    _get_root_scene_node -> SceneNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain__get_root_scene_node(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);
  {
    try {
      result = (Ogre::SceneNode *)((Ogre::Terrain const *)arg1)->_getRootSceneNode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.dirty

  call-seq:
    dirty

An instance method.

*/
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);
  {
    try {
      (arg1)->dirty();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.dirty_rect

  call-seq:
    dirty_rect(Rect rect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_dirty_rect(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);
  {
    try {
      (arg1)->dirtyRect((Ogre::Rect const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._dirty_composite_map_rect

  call-seq:
    _dirty_composite_map_rect(Rect rect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain__dirty_composite_map_rect(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);
  {
    try {
      (arg1)->_dirtyCompositeMapRect((Ogre::Rect const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.dirty_lightmap_rect

  call-seq:
    dirty_lightmap_rect(Rect rect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_dirty_lightmap_rect(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);
  {
    try {
      (arg1)->dirtyLightmapRect((Ogre::Rect const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.dirty_lightmap

  call-seq:
    dirty_lightmap

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_dirty_lightmap(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);
  {
    try {
      (arg1)->dirtyLightmap();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.update

  call-seq:
    update(bool synchronous=false)
    update

An instance method.

*/
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);
  {
    try {
      (arg1)->update(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_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);
  {
    try {
      (arg1)->update();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_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;
}



/*
  Document-method: Ogre::Terrain.update_geometry

  call-seq:
    update_geometry

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_update_geometry(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);
  {
    try {
      (arg1)->updateGeometry();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.DERIVED_DATA_DELTAS

  call-seq:
    DERIVED_DATA_DELTAS -> uint8

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_DERIVED_DATA_DELTAS

  call-seq:
    Terrain_DERIVED_DATA_DELTAS -> uint8

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.DERIVED_DATA_NORMALS

  call-seq:
    DERIVED_DATA_NORMALS -> uint8

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_DERIVED_DATA_NORMALS

  call-seq:
    Terrain_DERIVED_DATA_NORMALS -> uint8

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.DERIVED_DATA_LIGHTMAP

  call-seq:
    DERIVED_DATA_LIGHTMAP -> uint8

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_DERIVED_DATA_LIGHTMAP

  call-seq:
    Terrain_DERIVED_DATA_LIGHTMAP -> uint8

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.DERIVED_DATA_ALL

  call-seq:
    DERIVED_DATA_ALL -> uint8

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_DERIVED_DATA_ALL

  call-seq:
    Terrain_DERIVED_DATA_ALL -> uint8

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.update_derived_data

  call-seq:
    update_derived_data(bool synchronous=false, uint8 typeMask=0xFF)
    update_derived_data(bool synchronous=false)
    update_derived_data

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_update_derived_data__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);
  {
    try {
      (arg1)->updateDerivedData(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_update_derived_data__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);
  {
    try {
      (arg1)->updateDerivedData(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_update_derived_data__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);
  {
    try {
      (arg1)->updateDerivedData();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_update_derived_data(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_update_derived_data__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_update_derived_data__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_update_derived_data__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain.update_derived_data", 
    "    void Terrain.update_derived_data(bool synchronous, Ogre::uint8 typeMask)\n"
    "    void Terrain.update_derived_data(bool synchronous)\n"
    "    void Terrain.update_derived_data()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.update_composite_map

  call-seq:
    update_composite_map

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_update_composite_map(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);
  {
    try {
      (arg1)->updateCompositeMap();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.update_composite_map_with_delay

  call-seq:
    update_composite_map_with_delay(Real delay=2)
    update_composite_map_with_delay

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_update_composite_map_with_delay__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);
  {
    try {
      (arg1)->updateCompositeMapWithDelay(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_update_composite_map_with_delay__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);
  {
    try {
      (arg1)->updateCompositeMapWithDelay();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_update_composite_map_with_delay(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_composite_map_with_delay__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_update_composite_map_with_delay__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Terrain.update_composite_map_with_delay", 
    "    void Terrain.update_composite_map_with_delay(Ogre::Real delay)\n"
    "    void Terrain.update_composite_map_with_delay()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_skirt_size

  call-seq:
    get_skirt_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_skirt_size(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getSkirtSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_num_lod_levels

  call-seq:
    get_num_lod_levels -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_num_lod_levels(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getNumLodLevels();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_num_lod_levels_per_leaf

  call-seq:
    get_num_lod_levels_per_leaf -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_num_lod_levels_per_leaf(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getNumLodLevelsPerLeaf();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.calculate_height_deltas

  call-seq:
    calculate_height_deltas(Rect rect) -> Rect

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_calculate_height_deltas(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);
  {
    try {
      result = (arg1)->calculateHeightDeltas((Ogre::Rect const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Rect(static_cast< const Ogre::Rect& >(result))), SWIGTYPE_p_Ogre__TRectT_long_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.finalise_height_deltas

  call-seq:
    finalise_height_deltas(Rect rect, bool cpuData)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_finalise_height_deltas(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);
  {
    try {
      (arg1)->finaliseHeightDeltas((Ogre::Rect const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.calculate_normals

  call-seq:
    calculate_normals(Rect rect, Rect outFinalRect) -> PixelBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_calculate_normals(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);
  {
    try {
      result = (Ogre::PixelBox *)(arg1)->calculateNormals((Ogre::Rect const &)*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PixelBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.finalise_normals

  call-seq:
    finalise_normals(Rect rect, PixelBox normalsBox)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_finalise_normals(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);
  {
    try {
      (arg1)->finaliseNormals((Ogre::Rect const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.calculate_lightmap

  call-seq:
    calculate_lightmap(Rect rect, Rect extraTargetRect, Rect outFinalRect) -> PixelBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_calculate_lightmap(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);
  {
    try {
      result = (Ogre::PixelBox *)(arg1)->calculateLightmap((Ogre::Rect const &)*arg2,(Ogre::Rect const &)*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PixelBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.finalise_lightmap

  call-seq:
    finalise_lightmap(Rect rect, PixelBox lightmapBox)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_finalise_lightmap(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);
  {
    try {
      (arg1)->finaliseLightmap((Ogre::Rect const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_resolution_at_lod

  call-seq:
    get_resolution_at_lod(uint16 lodLevel) -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_resolution_at_lod(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);
  {
    try {
      result = (Ogre::uint16)(arg1)->getResolutionAtLod(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.ray_intersects

  call-seq:
    ray_intersects(Ray ray, bool cascadeToNeighbours=false, Real distanceLimit=0) -> std::pair<(bool,Ogre::Vector3)>
    ray_intersects(Ray ray, bool cascadeToNeighbours=false) -> std::pair<(bool,Ogre::Vector3)>
    ray_intersects(Ray ray) -> std::pair<(bool,Ogre::Vector3)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_ray_intersects__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);
  {
    try {
      result = (arg1)->rayIntersects((Ogre::Ray const &)*arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::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_ray_intersects__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);
  {
    try {
      result = (arg1)->rayIntersects((Ogre::Ray const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((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_ray_intersects__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);
  {
    try {
      result = (arg1)->rayIntersects((Ogre::Ray const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new 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_ray_intersects(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_ray_intersects__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_ray_intersects__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_ray_intersects__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Terrain.ray_intersects", 
    "    std::pair< bool,Ogre::Vector3 > Terrain.ray_intersects(Ogre::Ray const &ray, bool cascadeToNeighbours, Ogre::Real distanceLimit)\n"
    "    std::pair< bool,Ogre::Vector3 > Terrain.ray_intersects(Ogre::Ray const &ray, bool cascadeToNeighbours)\n"
    "    std::pair< bool,Ogre::Vector3 > Terrain.ray_intersects(Ogre::Ray const &ray)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_aabb

  call-seq:
    get_aabb -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_aabb(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);
  {
    try {
      result = (Ogre::AxisAlignedBox *) &((Ogre::Terrain const *)arg1)->getAABB();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_world_aabb

  call-seq:
    get_world_aabb -> AxisAlignedBox

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_world_aabb(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);
  {
    try {
      result = ((Ogre::Terrain const *)arg1)->getWorldAABB();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::AxisAlignedBox(static_cast< const Ogre::AxisAlignedBox& >(result))), SWIGTYPE_p_Ogre__AxisAlignedBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_min_height

  call-seq:
    get_min_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_min_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getMinHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_max_height

  call-seq:
    get_max_height -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_max_height(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getMaxHeight();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_bounding_radius

  call-seq:
    get_bounding_radius -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_bounding_radius(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);
  {
    try {
      result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_material

  call-seq:
    get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::Terrain const *)arg1)->getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._get_material

  call-seq:
    _get_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain__get_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::Terrain const *)arg1)->_getMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_composite_map_material

  call-seq:
    get_composite_map_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_composite_map_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::Terrain const *)arg1)->getCompositeMapMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._get_composite_map_material

  call-seq:
    _get_composite_map_material -> MaterialPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain__get_composite_map_material(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);
  {
    try {
      result = (Ogre::MaterialPtr *) &((Ogre::Terrain const *)arg1)->_getCompositeMapMaterial();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_material_name

  call-seq:
    get_material_name -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_material_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Terrain const *)arg1)->getMaterialName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.pre_find_visible_objects

  call-seq:
    pre_find_visible_objects(SceneManager source, IlluminationRenderStage irs, Viewport v)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_pre_find_visible_objects(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);
  {
    try {
      (arg1)->preFindVisibleObjects(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.scene_manager_destroyed

  call-seq:
    scene_manager_destroyed(SceneManager source)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_scene_manager_destroyed(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);
  {
    try {
      (arg1)->sceneManagerDestroyed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_render_queue_group

  call-seq:
    get_render_queue_group -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_render_queue_group(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::Terrain const *)arg1)->getRenderQueueGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.set_render_queue_group

  call-seq:
    set_render_queue_group(uint8 grp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_render_queue_group(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);
  {
    try {
      (arg1)->setRenderQueueGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_visibility_flags

  call-seq:
    get_visibility_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_visibility_flags(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::Terrain const *)arg1)->getVisibilityFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.set_visibility_flags

  call-seq:
    set_visibility_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_visibility_flags(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);
  {
    try {
      (arg1)->setVisibilityFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_query_flags

  call-seq:
    get_query_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_query_flags(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);
  {
    try {
      result = (Ogre::uint32)((Ogre::Terrain const *)arg1)->getQueryFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.set_query_flags

  call-seq:
    set_query_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_query_flags(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);
  {
    try {
      (arg1)->setQueryFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.add_query_flags

  call-seq:
    add_query_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_add_query_flags(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);
  {
    try {
      (arg1)->addQueryFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.remove_query_flags

  call-seq:
    remove_query_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_remove_query_flags(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);
  {
    try {
      (arg1)->removeQueryFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_layer_blend_map

  call-seq:
    get_layer_blend_map(uint8 layerIndex) -> TerrainLayerBlendMap

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_layer_blend_map(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);
  {
    try {
      result = (Ogre::TerrainLayerBlendMap *)(arg1)->getLayerBlendMap(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainLayerBlendMap, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_blend_texture_index

  call-seq:
    get_blend_texture_index(uint8 layerIndex) -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_blend_texture_index(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);
  {
    try {
      result = (Ogre::uint8)((Ogre::Terrain const *)arg1)->getBlendTextureIndex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_blend_texture_count

  call-seq:
    get_blend_texture_count -> uint8
    get_blend_texture_count(uint8 numLayers) -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_blend_texture_count__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);
  {
    try {
      result = (Ogre::uint8)((Ogre::Terrain const *)arg1)->getBlendTextureCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_get_blend_texture_count__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);
  {
    try {
      result = (Ogre::uint8)((Ogre::Terrain const *)arg1)->getBlendTextureCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_blend_texture_count(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_get_blend_texture_count__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_get_blend_texture_count__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Terrain.get_blend_texture_count", 
    "    Ogre::uint8 Terrain.get_blend_texture_count()\n"
    "    Ogre::uint8 Terrain.get_blend_texture_count(Ogre::uint8 numLayers)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_blend_texture_name

  call-seq:
    get_blend_texture_name(uint8 textureIndex) -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_blend_texture_name(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);
  {
    try {
      result = (Ogre::String *) &((Ogre::Terrain const *)arg1)->getBlendTextureName(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.set_global_colour_map_enabled

  call-seq:
    set_global_colour_map_enabled(bool enabled, uint16 size=0)
    set_global_colour_map_enabled(bool enabled)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_global_colour_map_enabled__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);
  {
    try {
      (arg1)->setGlobalColourMapEnabled(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_set_global_colour_map_enabled__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);
  {
    try {
      (arg1)->setGlobalColourMapEnabled(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_set_global_colour_map_enabled(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_set_global_colour_map_enabled__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_set_global_colour_map_enabled__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain.set_global_colour_map_enabled", 
    "    void Terrain.set_global_colour_map_enabled(bool enabled, Ogre::uint16 size)\n"
    "    void Terrain.set_global_colour_map_enabled(bool enabled)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_global_colour_map_enabled

  call-seq:
    get_global_colour_map_enabled -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_global_colour_map_enabled(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);
  {
    try {
      result = (bool)((Ogre::Terrain const *)arg1)->getGlobalColourMapEnabled();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_global_colour_map_size

  call-seq:
    get_global_colour_map_size -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_global_colour_map_size(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);
  {
    try {
      result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getGlobalColourMapSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_global_colour_map

  call-seq:
    get_global_colour_map -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_global_colour_map(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);
  {
    try {
      result = (Ogre::TexturePtr *) &((Ogre::Terrain const *)arg1)->getGlobalColourMap();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.widen_rect_by_vector

  call-seq:
    widen_rect_by_vector(Vector3 vec, Rect inRect, Rect outRect)
    widen_rect_by_vector(Vector3 vec, Rect inRect, Real minHeight, Real maxHeight, 
    Rect outRect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_widen_rect_by_vector__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);
  {
    try {
      (arg1)->widenRectByVector((Ogre::Vector3 const &)*arg2,(Ogre::Rect const &)*arg3,*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_widen_rect_by_vector__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);
  {
    try {
      (arg1)->widenRectByVector((Ogre::Vector3 const &)*arg2,(Ogre::Rect const &)*arg3,arg4,arg5,*arg6);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_widen_rect_by_vector(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_widen_rect_by_vector__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_widen_rect_by_vector__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Terrain.widen_rect_by_vector", 
    "    void Terrain.widen_rect_by_vector(Ogre::Vector3 const &vec, Ogre::Rect const &inRect, Ogre::Rect &outRect)\n"
    "    void Terrain.widen_rect_by_vector(Ogre::Vector3 const &vec, Ogre::Rect const &inRect, Ogre::Real minHeight, Ogre::Real maxHeight, Ogre::Rect &outRect)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.free_temporary_resources

  call-seq:
    free_temporary_resources

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_free_temporary_resources(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);
  {
    try {
      (arg1)->freeTemporaryResources();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_layer_blend_texture

  call-seq:
    get_layer_blend_texture(uint8 index) -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_layer_blend_texture(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);
  {
    try {
      result = (Ogre::TexturePtr *) &(arg1)->getLayerBlendTexture(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_layer_blend_texture_index

  call-seq:
    get_layer_blend_texture_index(uint8 layerIndex) -> std::pair<(Ogre::uint8,Ogre::uint8)>

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_layer_blend_texture_index(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);
  {
    try {
      result = (arg1)->getLayerBlendTextureIndex(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::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;
}



/*
  Document-method: Ogre::Terrain._set_morph_required

  call-seq:
    _set_morph_required(bool morph)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain__set_morph_required(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);
  {
    try {
      (arg1)->_setMorphRequired(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._get_morph_required

  call-seq:
    _get_morph_required -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain__get_morph_required(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);
  {
    try {
      result = (bool)((Ogre::Terrain const *)arg1)->_getMorphRequired();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._set_normal_map_required

  call-seq:
    _set_normal_map_required(bool normalMap)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain__set_normal_map_required(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);
  {
    try {
      (arg1)->_setNormalMapRequired(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._set_light_map_required

  call-seq:
    _set_light_map_required(bool lightMap, bool shadowsOnly=false)
    _set_light_map_required(bool lightMap)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain__set_light_map_required__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);
  {
    try {
      (arg1)->_setLightMapRequired(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__set_light_map_required__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);
  {
    try {
      (arg1)->_setLightMapRequired(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain__set_light_map_required(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__set_light_map_required__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__set_light_map_required__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain._set_light_map_required", 
    "    void Terrain._set_light_map_required(bool lightMap, bool shadowsOnly)\n"
    "    void Terrain._set_light_map_required(bool lightMap)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._set_composite_map_required

  call-seq:
    _set_composite_map_required(bool compositeMap)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain__set_composite_map_required(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);
  {
    try {
      (arg1)->_setCompositeMapRequired(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._get_use_vertex_compression

  call-seq:
    _get_use_vertex_compression -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain__get_use_vertex_compression(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);
  {
    try {
      result = (bool)((Ogre::Terrain const *)arg1)->_getUseVertexCompression();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.can_handle_request

  call-seq:
    can_handle_request(Request req, WorkQueue srcQ) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_can_handle_request(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);
  {
    try {
      result = (bool)(arg1)->canHandleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.handle_request

  call-seq:
    handle_request(Request req, WorkQueue srcQ) -> Response

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_handle_request(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);
  {
    try {
      result = (Ogre::WorkQueue::Response *)(arg1)->handleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.can_handle_response

  call-seq:
    can_handle_response(Response res, WorkQueue srcQ) -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_can_handle_response(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);
  {
    try {
      result = (bool)(arg1)->canHandleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.handle_response

  call-seq:
    handle_response(Response res, WorkQueue srcQ)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_handle_response(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);
  {
    try {
      (arg1)->handleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.WORKQUEUE_DERIVED_DATA_REQUEST

  call-seq:
    WORKQUEUE_DERIVED_DATA_REQUEST -> uint16

Get value of attribute.

*/

/*
  Document-method: Ogre::Terrain.Terrain_WORKQUEUE_DERIVED_DATA_REQUEST

  call-seq:
    Terrain_WORKQUEUE_DERIVED_DATA_REQUEST -> uint16

Get value of attribute.

*/
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;
}



/*
  Document-method: Ogre::Terrain.get_lodlevel_when_vertex_eliminated

  call-seq:
    get_lodlevel_when_vertex_eliminated(long x, long y) -> uint16
    get_lodlevel_when_vertex_eliminated(long rowOrColulmn) -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_lodlevel_when_vertex_eliminated__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);
  {
    try {
      result = (Ogre::uint16)(arg1)->getLODLevelWhenVertexEliminated(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_get_lodlevel_when_vertex_eliminated__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);
  {
    try {
      result = (Ogre::uint16)(arg1)->getLODLevelWhenVertexEliminated(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_get_lodlevel_when_vertex_eliminated(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_get_lodlevel_when_vertex_eliminated__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_get_lodlevel_when_vertex_eliminated__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain.get_lodlevel_when_vertex_eliminated", 
    "    Ogre::uint16 Terrain.get_lodlevel_when_vertex_eliminated(long x, long y)\n"
    "    Ogre::uint16 Terrain.get_lodlevel_when_vertex_eliminated(long rowOrColulmn)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_quad_tree

  call-seq:
    get_quad_tree -> TerrainQuadTreeNode

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_quad_tree(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);
  {
    try {
      result = (Ogre::TerrainQuadTreeNode *)(arg1)->getQuadTree();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainQuadTreeNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_terrain_normal_map

  call-seq:
    get_terrain_normal_map -> TexturePtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_terrain_normal_map(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);
  {
    try {
      result = ((Ogre::Terrain const *)arg1)->getTerrainNormalMap();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_neighbour

  call-seq:
    get_neighbour(NeighbourIndex index) -> Terrain

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_neighbour(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);
  {
    try {
      result = (Ogre::Terrain *)(arg1)->getNeighbour(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.set_neighbour

  call-seq:
    set_neighbour(NeighbourIndex index, Terrain neighbour, bool recalculate=false, 
    bool notifyOther=true)
    set_neighbour(NeighbourIndex index, Terrain neighbour, bool recalculate=false)
    set_neighbour(NeighbourIndex index, Terrain neighbour)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_set_neighbour__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);
  {
    try {
      (arg1)->setNeighbour(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_set_neighbour__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);
  {
    try {
      (arg1)->setNeighbour(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_set_neighbour__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);
  {
    try {
      (arg1)->setNeighbour(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_set_neighbour(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_set_neighbour__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_set_neighbour__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_set_neighbour__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.set_neighbour", 
    "    void Terrain.set_neighbour(Ogre::Terrain::NeighbourIndex index, Ogre::Terrain *neighbour, bool recalculate, bool notifyOther)\n"
    "    void Terrain.set_neighbour(Ogre::Terrain::NeighbourIndex index, Ogre::Terrain *neighbour, bool recalculate)\n"
    "    void Terrain.set_neighbour(Ogre::Terrain::NeighbourIndex index, Ogre::Terrain *neighbour)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_opposite_neighbour

  call-seq:
    get_opposite_neighbour(NeighbourIndex index) -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_opposite_neighbour(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);
  {
    try {
      result = (Ogre::Terrain::NeighbourIndex)Ogre::Terrain::getOppositeNeighbour(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.get_neighbour_index

  call-seq:
    get_neighbour_index(long offsetx, long offsety) -> int

A class method.

*/
SWIGINTERN VALUE
_wrap_Terrain_get_neighbour_index(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);
  {
    try {
      result = (Ogre::Terrain::NeighbourIndex)Ogre::Terrain::getNeighbourIndex(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.notify_neighbours

  call-seq:
    notify_neighbours

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_notify_neighbours(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);
  {
    try {
      (arg1)->notifyNeighbours();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.neighbour_modified

  call-seq:
    neighbour_modified(NeighbourIndex index, Rect edgerect, Rect shadowrect)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_neighbour_modified(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);
  {
    try {
      (arg1)->neighbourModified(arg2,(Ogre::Rect const &)*arg3,(Ogre::Rect const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.ray_select_neighbour

  call-seq:
    ray_select_neighbour(Ray ray, Real distanceLimit=0) -> Terrain
    ray_select_neighbour(Ray ray) -> Terrain

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_ray_select_neighbour__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);
  {
    try {
      result = (Ogre::Terrain *)(arg1)->raySelectNeighbour((Ogre::Ray const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_ray_select_neighbour__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);
  {
    try {
      result = (Ogre::Terrain *)(arg1)->raySelectNeighbour((Ogre::Ray const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_ray_select_neighbour(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_ray_select_neighbour__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_ray_select_neighbour__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain.ray_select_neighbour", 
    "    Ogre::Terrain * Terrain.ray_select_neighbour(Ogre::Ray const &ray, Ogre::Real distanceLimit)\n"
    "    Ogre::Terrain * Terrain.ray_select_neighbour(Ogre::Ray const &ray)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Terrain._dump_textures

  call-seq:
    _dump_textures(String prefix, String suffix)

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain__dump_textures(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;
  }
  {
    try {
      (arg1)->_dumpTextures((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  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;
}



/*
  Document-method: Ogre::Terrain.is_derived_data_update_in_progress

  call-seq:
    is_derived_data_update_in_progress -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_Terrain_is_derived_data_update_in_progress(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);
  {
    try {
      result = (bool)((Ogre::Terrain const *)arg1)->isDerivedDataUpdateInProgress();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.convert_world_to_terrain_axes

  call-seq:
    convert_world_to_terrain_axes(Alignment align, Vector3 worldVec, Vector3 terrainVec)

A class method.

*/
SWIGINTERN VALUE
_wrap_Terrain_convert_world_to_terrain_axes(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);
  {
    try {
      Ogre::Terrain::convertWorldToTerrainAxes(arg1,(Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.convert_terrain_to_world_axes

  call-seq:
    convert_terrain_to_world_axes(Alignment align, Vector3 terrainVec, Vector3 worldVec)

A class method.

*/
SWIGINTERN VALUE
_wrap_Terrain_convert_terrain_to_world_axes(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);
  {
    try {
      Ogre::Terrain::convertTerrainToWorldAxes(arg1,(Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.write_layer_declaration

  call-seq:
    write_layer_declaration(TerrainLayerDeclaration decl, StreamSerialiser ser)

A class method.

*/
SWIGINTERN VALUE
_wrap_Terrain_write_layer_declaration(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);
  {
    try {
      Ogre::Terrain::writeLayerDeclaration((Ogre::TerrainLayerDeclaration const &)*arg1,*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.read_layer_declaration

  call-seq:
    read_layer_declaration(StreamSerialiser ser, TerrainLayerDeclaration targetdecl) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_Terrain_read_layer_declaration(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);
  {
    try {
      result = (bool)Ogre::Terrain::readLayerDeclaration(*arg1,*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.write_layer_instance_list

  call-seq:
    write_layer_instance_list(LayerInstanceList lst, StreamSerialiser ser)

A class method.

*/
SWIGINTERN VALUE
_wrap_Terrain_write_layer_instance_list(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);
  {
    try {
      Ogre::Terrain::writeLayerInstanceList((Ogre::vector< LayerInstance,Ogre::STLAllocator< LayerInstance,Ogre::GeneralAllocPolicy > >::type const &)*arg1,*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Terrain.read_layer_instance_list

  call-seq:
    read_layer_instance_list(StreamSerialiser ser, size_t numSamplers, LayerInstanceList targetlst) -> bool

A class method.

*/
SWIGINTERN VALUE
_wrap_Terrain_read_layer_instance_list(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);
  {
    try {
      result = (bool)Ogre::Terrain::readLayerInstanceList(*arg1,arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-class: Ogre::TerrainGlobalOptions

  Proxy of C++ Ogre::TerrainGlobalOptions class


*/
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;
  }
  


/*
  Document-method: Ogre::TerrainGlobalOptions.new

  call-seq:
    TerrainGlobalOptions.new

Class constructor.

*/
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;
  }
  {
    try {
      result = (Ogre::TerrainGlobalOptions *)new Ogre::TerrainGlobalOptions();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainGlobalOptions(Ogre::TerrainGlobalOptions *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::TerrainGlobalOptions.get_skirt_size

  call-seq:
    get_skirt_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_skirt_size(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getSkirtSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_skirt_size

  call-seq:
    set_skirt_size(Real skirtSz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_skirt_size(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);
  {
    try {
      (arg1)->setSkirtSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_light_map_direction

  call-seq:
    get_light_map_direction -> Vector3

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_light_map_direction(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);
  {
    try {
      result = (Ogre::Vector3 *) &(arg1)->getLightMapDirection();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_light_map_direction

  call-seq:
    set_light_map_direction(Vector3 v)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_light_map_direction(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);
  {
    try {
      (arg1)->setLightMapDirection((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_composite_map_ambient

  call-seq:
    get_composite_map_ambient -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_composite_map_ambient(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);
  {
    try {
      result = (Ogre::ColourValue *) &(arg1)->getCompositeMapAmbient();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_composite_map_ambient

  call-seq:
    set_composite_map_ambient(ColourValue c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_composite_map_ambient(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);
  {
    try {
      (arg1)->setCompositeMapAmbient((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_composite_map_diffuse

  call-seq:
    get_composite_map_diffuse -> ColourValue

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_composite_map_diffuse(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);
  {
    try {
      result = (Ogre::ColourValue *) &(arg1)->getCompositeMapDiffuse();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_composite_map_diffuse

  call-seq:
    set_composite_map_diffuse(ColourValue c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_composite_map_diffuse(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);
  {
    try {
      (arg1)->setCompositeMapDiffuse((Ogre::ColourValue const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_composite_map_distance

  call-seq:
    get_composite_map_distance -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_composite_map_distance(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getCompositeMapDistance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_composite_map_distance

  call-seq:
    set_composite_map_distance(Real c)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_composite_map_distance(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);
  {
    try {
      (arg1)->setCompositeMapDistance(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_casts_dynamic_shadows

  call-seq:
    get_casts_dynamic_shadows -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_casts_dynamic_shadows(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);
  {
    try {
      result = (bool)(arg1)->getCastsDynamicShadows();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_casts_dynamic_shadows

  call-seq:
    set_casts_dynamic_shadows(bool s)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_casts_dynamic_shadows(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);
  {
    try {
      (arg1)->setCastsDynamicShadows(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_max_pixel_error

  call-seq:
    get_max_pixel_error -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_max_pixel_error(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getMaxPixelError();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_max_pixel_error

  call-seq:
    set_max_pixel_error(Real pixerr)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_max_pixel_error(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);
  {
    try {
      (arg1)->setMaxPixelError(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_render_queue_group

  call-seq:
    get_render_queue_group -> uint8

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_render_queue_group(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);
  {
    try {
      result = (Ogre::uint8)(arg1)->getRenderQueueGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_render_queue_group

  call-seq:
    set_render_queue_group(uint8 grp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_render_queue_group(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);
  {
    try {
      (arg1)->setRenderQueueGroup(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_visibility_flags

  call-seq:
    get_visibility_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_visibility_flags(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);
  {
    try {
      result = (Ogre::uint32)(arg1)->getVisibilityFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_visibility_flags

  call-seq:
    set_visibility_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_visibility_flags(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);
  {
    try {
      (arg1)->setVisibilityFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_query_flags

  call-seq:
    set_query_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_query_flags(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);
  {
    try {
      (arg1)->setQueryFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_query_flags

  call-seq:
    get_query_flags -> uint32

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_query_flags(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);
  {
    try {
      result = (Ogre::uint32)(arg1)->getQueryFlags();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.add_query_flags

  call-seq:
    add_query_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_add_query_flags(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);
  {
    try {
      (arg1)->addQueryFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.remove_query_flags

  call-seq:
    remove_query_flags(uint32 flags)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_remove_query_flags(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);
  {
    try {
      (arg1)->removeQueryFlags(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_use_ray_box_distance_calculation

  call-seq:
    get_use_ray_box_distance_calculation -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_use_ray_box_distance_calculation(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);
  {
    try {
      result = (bool)(arg1)->getUseRayBoxDistanceCalculation();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_use_ray_box_distance_calculation

  call-seq:
    set_use_ray_box_distance_calculation(bool rb)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_use_ray_box_distance_calculation(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);
  {
    try {
      (arg1)->setUseRayBoxDistanceCalculation(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_default_material_generator

  call-seq:
    get_default_material_generator -> TerrainMaterialGeneratorPtr

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_default_material_generator(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);
  {
    try {
      result = (arg1)->getDefaultMaterialGenerator();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::TerrainMaterialGeneratorPtr(static_cast< const Ogre::TerrainMaterialGeneratorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__TerrainMaterialGenerator_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_default_material_generator

  call-seq:
    set_default_material_generator(TerrainMaterialGeneratorPtr gen)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_default_material_generator(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));
    }
  }
  {
    try {
      (arg1)->setDefaultMaterialGenerator(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_layer_blend_map_size

  call-seq:
    get_layer_blend_map_size -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_layer_blend_map_size(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);
  {
    try {
      result = (Ogre::uint16)(arg1)->getLayerBlendMapSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_layer_blend_map_size

  call-seq:
    set_layer_blend_map_size(uint16 sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_layer_blend_map_size(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);
  {
    try {
      (arg1)->setLayerBlendMapSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_default_layer_texture_world_size

  call-seq:
    get_default_layer_texture_world_size -> Real

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_default_layer_texture_world_size(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);
  {
    try {
      result = (Ogre::Real)(arg1)->getDefaultLayerTextureWorldSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_default_layer_texture_world_size

  call-seq:
    set_default_layer_texture_world_size(Real sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_default_layer_texture_world_size(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);
  {
    try {
      (arg1)->setDefaultLayerTextureWorldSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_default_global_colour_map_size

  call-seq:
    get_default_global_colour_map_size -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_default_global_colour_map_size(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);
  {
    try {
      result = (Ogre::uint16)(arg1)->getDefaultGlobalColourMapSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_default_global_colour_map_size

  call-seq:
    set_default_global_colour_map_size(uint16 sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_default_global_colour_map_size(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);
  {
    try {
      (arg1)->setDefaultGlobalColourMapSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_light_map_size

  call-seq:
    get_light_map_size -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_light_map_size(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);
  {
    try {
      result = (Ogre::uint16)(arg1)->getLightMapSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_light_map_size

  call-seq:
    set_light_map_size(uint16 sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_light_map_size(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);
  {
    try {
      (arg1)->setLightMapSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_composite_map_size

  call-seq:
    get_composite_map_size -> uint16

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_composite_map_size(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);
  {
    try {
      result = (Ogre::uint16)(arg1)->getCompositeMapSize();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_composite_map_size

  call-seq:
    set_composite_map_size(uint16 sz)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_composite_map_size(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);
  {
    try {
      (arg1)->setCompositeMapSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_default_resource_group

  call-seq:
    set_default_resource_group(String grp)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_default_resource_group(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;
  }
  {
    try {
      (arg1)->setDefaultResourceGroup((Ogre::String const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_default_resource_group

  call-seq:
    get_default_resource_group -> String

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_default_resource_group(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);
  {
    try {
      result = (Ogre::String *) &(arg1)->getDefaultResourceGroup();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_use_vertex_compression_when_available

  call-seq:
    get_use_vertex_compression_when_available -> bool

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_use_vertex_compression_when_available(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);
  {
    try {
      result = (bool)((Ogre::TerrainGlobalOptions const *)arg1)->getUseVertexCompressionWhenAvailable();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.set_use_vertex_compression_when_available

  call-seq:
    set_use_vertex_compression_when_available(bool enable)

An instance method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_set_use_vertex_compression_when_available(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);
  {
    try {
      (arg1)->setUseVertexCompressionWhenAvailable(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_singleton

  call-seq:
    get_singleton -> TerrainGlobalOptions

A class method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_singleton(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;
  }
  {
    try {
      result = (Ogre::TerrainGlobalOptions *) &Ogre::TerrainGlobalOptions::getSingleton();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainGlobalOptions, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainGlobalOptions.get_singleton_ptr

  call-seq:
    get_singleton_ptr -> TerrainGlobalOptions

A class method.

*/
SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_get_singleton_ptr(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;
  }
  {
    try {
      result = (Ogre::TerrainGlobalOptions *)Ogre::TerrainGlobalOptions::getSingletonPtr();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__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;
  
  SwigClassGCVALUE.klass = rb_define_class_under(mOgre, "GCVALUE", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_swig__GC_VALUE, (void *) &SwigClassGCVALUE);
  rb_undef_alloc_func(SwigClassGCVALUE.klass);
  rb_define_method(SwigClassGCVALUE.klass, "inspect", VALUEFUNC(_wrap_GCVALUE_inspect), -1);
  rb_define_method(SwigClassGCVALUE.klass, "to_s", VALUEFUNC(_wrap_GCVALUE_to_s), -1);
  SwigClassGCVALUE.mark = 0;
  SwigClassGCVALUE.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 >(1)));
  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)|1))));
  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_APPLE_IOS", SWIG_From_int(static_cast< int >(4)));
  rb_define_const(mOgre, "OGRE_PLATFORM_ANDROID", SWIG_From_int(static_cast< int >(5)));
  rb_define_const(mOgre, "OGRE_PLATFORM_NACL", SWIG_From_int(static_cast< int >(6)));
  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)));
  
  SwigClassVertexBoneAssignmentS.klass = rb_define_class_under(mOgre, "VertexBoneAssignmentS", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__VertexBoneAssignment_s, (void *) &SwigClassVertexBoneAssignmentS);
  rb_define_alloc_func(SwigClassVertexBoneAssignmentS.klass, _wrap_VertexBoneAssignmentS_allocate);
  rb_define_method(SwigClassVertexBoneAssignmentS.klass, "initialize", VALUEFUNC(_wrap_new_VertexBoneAssignmentS), -1);
  rb_define_method(SwigClassVertexBoneAssignmentS.klass, "vertexIndex=", VALUEFUNC(_wrap_VertexBoneAssignmentS_vertexIndex_set), -1);
  rb_define_method(SwigClassVertexBoneAssignmentS.klass, "vertexIndex", VALUEFUNC(_wrap_VertexBoneAssignmentS_vertexIndex_get), -1);
  rb_define_method(SwigClassVertexBoneAssignmentS.klass, "boneIndex=", VALUEFUNC(_wrap_VertexBoneAssignmentS_boneIndex_set), -1);
  rb_define_method(SwigClassVertexBoneAssignmentS.klass, "boneIndex", VALUEFUNC(_wrap_VertexBoneAssignmentS_boneIndex_get), -1);
  rb_define_method(SwigClassVertexBoneAssignmentS.klass, "weight=", VALUEFUNC(_wrap_VertexBoneAssignmentS_weight_set), -1);
  rb_define_method(SwigClassVertexBoneAssignmentS.klass, "weight", VALUEFUNC(_wrap_VertexBoneAssignmentS_weight_get), -1);
  SwigClassVertexBoneAssignmentS.mark = 0;
  SwigClassVertexBoneAssignmentS.destroy = (void (*)(void *)) free_Ogre_VertexBoneAssignment;
  SwigClassVertexBoneAssignmentS.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, "value_degrees", VALUEFUNC(_wrap_Radian_value_degrees), -1);
  rb_define_method(SwigClassRadian.klass, "value_radians", VALUEFUNC(_wrap_Radian_value_radians), -1);
  rb_define_method(SwigClassRadian.klass, "value_angle_units", VALUEFUNC(_wrap_Radian_value_angle_units), -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, "value_degrees", VALUEFUNC(_wrap_Degree_value_degrees), -1);
  rb_define_method(SwigClassDegree.klass, "value_radians", VALUEFUNC(_wrap_Degree_value_radians), -1);
  rb_define_method(SwigClassDegree.klass, "value_angle_units", VALUEFUNC(_wrap_Degree_value_angle_units), -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, "is_na_n", VALUEFUNC(_wrap_Math_is_na_n), -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, "log_n", VALUEFUNC(_wrap_Math_log_n), -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, "inv_sqrt", VALUEFUNC(_wrap_Math_inv_sqrt), -1);
  rb_define_singleton_method(SwigClassMath.klass, "unit_random", VALUEFUNC(_wrap_Math_unit_random), -1);
  rb_define_singleton_method(SwigClassMath.klass, "range_random", VALUEFUNC(_wrap_Math_range_random), -1);
  rb_define_singleton_method(SwigClassMath.klass, "symmetric_random", VALUEFUNC(_wrap_Math_symmetric_random), -1);
  rb_define_singleton_method(SwigClassMath.klass, "tan", VALUEFUNC(_wrap_Math_tan), -1);
  rb_define_singleton_method(SwigClassMath.klass, "degrees_to_radians", VALUEFUNC(_wrap_Math_degrees_to_radians), -1);
  rb_define_singleton_method(SwigClassMath.klass, "radians_to_degrees", VALUEFUNC(_wrap_Math_radians_to_degrees), -1);
  rb_define_singleton_method(SwigClassMath.klass, "set_angle_unit", VALUEFUNC(_wrap_Math_set_angle_unit), -1);
  rb_define_singleton_method(SwigClassMath.klass, "get_angle_unit", VALUEFUNC(_wrap_Math_get_angle_unit), -1);
  rb_define_singleton_method(SwigClassMath.klass, "angle_units_to_radians", VALUEFUNC(_wrap_Math_angle_units_to_radians), -1);
  rb_define_singleton_method(SwigClassMath.klass, "radians_to_angle_units", VALUEFUNC(_wrap_Math_radians_to_angle_units), -1);
  rb_define_singleton_method(SwigClassMath.klass, "angle_units_to_degrees", VALUEFUNC(_wrap_Math_angle_units_to_degrees), -1);
  rb_define_singleton_method(SwigClassMath.klass, "degrees_to_angle_units", VALUEFUNC(_wrap_Math_degrees_to_angle_units), -1);
  rb_define_singleton_method(SwigClassMath.klass, "point_in_tri_2d", VALUEFUNC(_wrap_Math_point_in_tri_2d), -1);
  rb_define_singleton_method(SwigClassMath.klass, "point_in_tri_3d", VALUEFUNC(_wrap_Math_point_in_tri_3d), -1);
  rb_define_singleton_method(SwigClassMath.klass, "intersects", VALUEFUNC(_wrap_Math_intersects), -1);
  rb_define_singleton_method(SwigClassMath.klass, "real_equal", VALUEFUNC(_wrap_Math_real_equal), -1);
  rb_define_singleton_method(SwigClassMath.klass, "calculate_tangent_space_vector", VALUEFUNC(_wrap_Math_calculate_tangent_space_vector), -1);
  rb_define_singleton_method(SwigClassMath.klass, "build_reflection_matrix", VALUEFUNC(_wrap_Math_build_reflection_matrix), -1);
  rb_define_singleton_method(SwigClassMath.klass, "calculate_face_normal", VALUEFUNC(_wrap_Math_calculate_face_normal), -1);
  rb_define_singleton_method(SwigClassMath.klass, "calculate_basic_face_normal", VALUEFUNC(_wrap_Math_calculate_basic_face_normal), -1);
  rb_define_singleton_method(SwigClassMath.klass, "calculate_face_normal_without_normalize", VALUEFUNC(_wrap_Math_calculate_face_normal_without_normalize), -1);
  rb_define_singleton_method(SwigClassMath.klass, "calculate_basic_face_normal_without_normalize", VALUEFUNC(_wrap_Math_calculate_basic_face_normal_without_normalize), -1);
  rb_define_singleton_method(SwigClassMath.klass, "gaussian_distribution", VALUEFUNC(_wrap_Math_gaussian_distribution), -1);
  rb_define_singleton_method(SwigClassMath.klass, "make_view_matrix", VALUEFUNC(_wrap_Math_make_view_matrix), -1);
  rb_define_singleton_method(SwigClassMath.klass, "bounding_radius_from_aabb", VALUEFUNC(_wrap_Math_bounding_radius_from_aabb), -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, "squared_length", VALUEFUNC(_wrap_Vector2_squared_length), -1);
  rb_define_method(SwigClassVector2.klass, "distance", VALUEFUNC(_wrap_Vector2_distance), -1);
  rb_define_method(SwigClassVector2.klass, "squared_distance", VALUEFUNC(_wrap_Vector2_squared_distance), -1);
  rb_define_method(SwigClassVector2.klass, "dot_product", VALUEFUNC(_wrap_Vector2_dot_product), -1);
  rb_define_method(SwigClassVector2.klass, "normalise", VALUEFUNC(_wrap_Vector2_normalise), -1);
  rb_define_method(SwigClassVector2.klass, "mid_point", VALUEFUNC(_wrap_Vector2_mid_point), -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, "make_floor", VALUEFUNC(_wrap_Vector2_make_floor), -1);
  rb_define_method(SwigClassVector2.klass, "make_ceil", VALUEFUNC(_wrap_Vector2_make_ceil), -1);
  rb_define_method(SwigClassVector2.klass, "perpendicular", VALUEFUNC(_wrap_Vector2_perpendicular), -1);
  rb_define_method(SwigClassVector2.klass, "cross_product", VALUEFUNC(_wrap_Vector2_cross_product), -1);
  rb_define_method(SwigClassVector2.klass, "random_deviant", VALUEFUNC(_wrap_Vector2_random_deviant), -1);
  rb_define_method(SwigClassVector2.klass, "is_zero_length", VALUEFUNC(_wrap_Vector2_is_zero_length), -1);
  rb_define_method(SwigClassVector2.klass, "normalised_copy", VALUEFUNC(_wrap_Vector2_normalised_copy), -1);
  rb_define_method(SwigClassVector2.klass, "reflect", VALUEFUNC(_wrap_Vector2_reflect), -1);
  rb_define_method(SwigClassVector2.klass, "is_na_n", VALUEFUNC(_wrap_Vector2_is_na_n), -1);
  rb_define_method(SwigClassVector2.klass, "angle_between", VALUEFUNC(_wrap_Vector2_angle_between), -1);
  rb_define_method(SwigClassVector2.klass, "angle_to", VALUEFUNC(_wrap_Vector2_angle_to), -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, "from_rotation_matrix", VALUEFUNC(_wrap_Quaternion_from_rotation_matrix), -1);
  rb_define_method(SwigClassQuaternion.klass, "to_rotation_matrix", VALUEFUNC(_wrap_Quaternion_to_rotation_matrix), -1);
  rb_define_method(SwigClassQuaternion.klass, "from_angle_axis", VALUEFUNC(_wrap_Quaternion_from_angle_axis), -1);
  rb_define_method(SwigClassQuaternion.klass, "to_angle_axis", VALUEFUNC(_wrap_Quaternion_to_angle_axis), -1);
  rb_define_method(SwigClassQuaternion.klass, "from_axes", VALUEFUNC(_wrap_Quaternion_from_axes), -1);
  rb_define_method(SwigClassQuaternion.klass, "to_axes", VALUEFUNC(_wrap_Quaternion_to_axes), -1);
  rb_define_method(SwigClassQuaternion.klass, "x_axis", VALUEFUNC(_wrap_Quaternion_x_axis), -1);
  rb_define_method(SwigClassQuaternion.klass, "y_axis", VALUEFUNC(_wrap_Quaternion_y_axis), -1);
  rb_define_method(SwigClassQuaternion.klass, "z_axis", VALUEFUNC(_wrap_Quaternion_z_axis), -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, "unit_inverse", VALUEFUNC(_wrap_Quaternion_unit_inverse), -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, "get_roll", VALUEFUNC(_wrap_Quaternion_get_roll), -1);
  rb_define_method(SwigClassQuaternion.klass, "get_pitch", VALUEFUNC(_wrap_Quaternion_get_pitch), -1);
  rb_define_method(SwigClassQuaternion.klass, "get_yaw", VALUEFUNC(_wrap_Quaternion_get_yaw), -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, "slerp_extra_spins", VALUEFUNC(_wrap_Quaternion_slerp_extra_spins), -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, "is_na_n", VALUEFUNC(_wrap_Quaternion_is_na_n), -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, "squared_length", VALUEFUNC(_wrap_Vector3_squared_length), -1);
  rb_define_method(SwigClassVector3.klass, "distance", VALUEFUNC(_wrap_Vector3_distance), -1);
  rb_define_method(SwigClassVector3.klass, "squared_distance", VALUEFUNC(_wrap_Vector3_squared_distance), -1);
  rb_define_method(SwigClassVector3.klass, "dot_product", VALUEFUNC(_wrap_Vector3_dot_product), -1);
  rb_define_method(SwigClassVector3.klass, "abs_dot_product", VALUEFUNC(_wrap_Vector3_abs_dot_product), -1);
  rb_define_method(SwigClassVector3.klass, "normalise", VALUEFUNC(_wrap_Vector3_normalise), -1);
  rb_define_method(SwigClassVector3.klass, "cross_product", VALUEFUNC(_wrap_Vector3_cross_product), -1);
  rb_define_method(SwigClassVector3.klass, "mid_point", VALUEFUNC(_wrap_Vector3_mid_point), -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, "make_floor", VALUEFUNC(_wrap_Vector3_make_floor), -1);
  rb_define_method(SwigClassVector3.klass, "make_ceil", VALUEFUNC(_wrap_Vector3_make_ceil), -1);
  rb_define_method(SwigClassVector3.klass, "perpendicular", VALUEFUNC(_wrap_Vector3_perpendicular), -1);
  rb_define_method(SwigClassVector3.klass, "random_deviant", VALUEFUNC(_wrap_Vector3_random_deviant), -1);
  rb_define_method(SwigClassVector3.klass, "angle_between", VALUEFUNC(_wrap_Vector3_angle_between), -1);
  rb_define_method(SwigClassVector3.klass, "get_rotation_to", VALUEFUNC(_wrap_Vector3_get_rotation_to), -1);
  rb_define_method(SwigClassVector3.klass, "is_zero_length", VALUEFUNC(_wrap_Vector3_is_zero_length), -1);
  rb_define_method(SwigClassVector3.klass, "normalised_copy", VALUEFUNC(_wrap_Vector3_normalised_copy), -1);
  rb_define_method(SwigClassVector3.klass, "reflect", VALUEFUNC(_wrap_Vector3_reflect), -1);
  rb_define_method(SwigClassVector3.klass, "position_equals", VALUEFUNC(_wrap_Vector3_position_equals), -1);
  rb_define_method(SwigClassVector3.klass, "position_closes", VALUEFUNC(_wrap_Vector3_position_closes), -1);
  rb_define_method(SwigClassVector3.klass, "direction_equals", VALUEFUNC(_wrap_Vector3_direction_equals), -1);
  rb_define_method(SwigClassVector3.klass, "is_na_n", VALUEFUNC(_wrap_Vector3_is_na_n), -1);
  rb_define_method(SwigClassVector3.klass, "primary_axis", VALUEFUNC(_wrap_Vector3_primary_axis), -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, "dot_product", VALUEFUNC(_wrap_Vector4_dot_product), -1);
  rb_define_method(SwigClassVector4.klass, "is_na_n", VALUEFUNC(_wrap_Vector4_is_na_n), -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, "get_as_rgba", VALUEFUNC(_wrap_ColourValue_get_as_rgba), -1);
  rb_define_method(SwigClassColourValue.klass, "get_as_argb", VALUEFUNC(_wrap_ColourValue_get_as_argb), -1);
  rb_define_method(SwigClassColourValue.klass, "get_as_bgra", VALUEFUNC(_wrap_ColourValue_get_as_bgra), -1);
  rb_define_method(SwigClassColourValue.klass, "get_as_abgr", VALUEFUNC(_wrap_ColourValue_get_as_abgr), -1);
  rb_define_method(SwigClassColourValue.klass, "set_as_rgba", VALUEFUNC(_wrap_ColourValue_set_as_rgba), -1);
  rb_define_method(SwigClassColourValue.klass, "set_as_argb", VALUEFUNC(_wrap_ColourValue_set_as_argb), -1);
  rb_define_method(SwigClassColourValue.klass, "set_as_bgra", VALUEFUNC(_wrap_ColourValue_set_as_bgra), -1);
  rb_define_method(SwigClassColourValue.klass, "set_as_abgr", VALUEFUNC(_wrap_ColourValue_set_as_abgr), -1);
  rb_define_method(SwigClassColourValue.klass, "saturate", VALUEFUNC(_wrap_ColourValue_saturate), -1);
  rb_define_method(SwigClassColourValue.klass, "saturate_copy", VALUEFUNC(_wrap_ColourValue_saturate_copy), -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, "set_hsb", VALUEFUNC(_wrap_ColourValue_set_hsb), -1);
  rb_define_method(SwigClassColourValue.klass, "get_hsb", VALUEFUNC(_wrap_ColourValue_get_hsb), -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, "to_lower_case", VALUEFUNC(_wrap_StringUtil_to_lower_case), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "to_upper_case", VALUEFUNC(_wrap_StringUtil_to_upper_case), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "starts_with", VALUEFUNC(_wrap_StringUtil_starts_with), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "ends_with", VALUEFUNC(_wrap_StringUtil_ends_with), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "standardise_path", VALUEFUNC(_wrap_StringUtil_standardise_path), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "normalize_file_path", VALUEFUNC(_wrap_StringUtil_normalize_file_path), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "split_filename", VALUEFUNC(_wrap_StringUtil_split_filename), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "split_full_filename", VALUEFUNC(_wrap_StringUtil_split_full_filename), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "split_base_filename", VALUEFUNC(_wrap_StringUtil_split_base_filename), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "match", VALUEFUNC(_wrap_StringUtil_match), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "replace_all", VALUEFUNC(_wrap_StringUtil_replace_all), -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, "get_full_description", VALUEFUNC(_wrap_Exception_get_full_description), -1);
  rb_define_method(SwigClassException.klass, "get_number", VALUEFUNC(_wrap_Exception_get_number), -1);
  rb_define_method(SwigClassException.klass, "get_source", VALUEFUNC(_wrap_Exception_get_source), -1);
  rb_define_method(SwigClassException.klass, "get_file", VALUEFUNC(_wrap_Exception_get_file), -1);
  rb_define_method(SwigClassException.klass, "get_line", VALUEFUNC(_wrap_Exception_get_line), -1);
  rb_define_method(SwigClassException.klass, "get_description", VALUEFUNC(_wrap_Exception_get_description), -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, "is_empty", VALUEFUNC(_wrap_Any_is_empty), -1);
  rb_define_method(SwigClassAny.klass, "get_type", VALUEFUNC(_wrap_Any_get_type), -1);
  rb_define_method(SwigClassAny.klass, "destroy", VALUEFUNC(_wrap_Any_destroy), -1);
  rb_define_method(SwigClassAny.klass, "to_value", VALUEFUNC(_wrap_Any_to_value), -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, "set_value", VALUEFUNC(_wrap_AnyVALUE_set_value), -1);
  rb_define_method(SwigClassAnyVALUE.klass, "get_value", VALUEFUNC(_wrap_AnyVALUE_get_value), -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, "get_type", VALUEFUNC(_wrap_AnimableValue_get_type), -1);
  rb_define_method(SwigClassAnimableValue.klass, "set_current_state_as_base_value", VALUEFUNC(_wrap_AnimableValue_set_current_state_as_base_value), -1);
  rb_define_method(SwigClassAnimableValue.klass, "set_value", VALUEFUNC(_wrap_AnimableValue_set_value), -1);
  rb_define_method(SwigClassAnimableValue.klass, "reset_to_base_value", VALUEFUNC(_wrap_AnimableValue_reset_to_base_value), -1);
  rb_define_method(SwigClassAnimableValue.klass, "apply_delta_value", VALUEFUNC(_wrap_AnimableValue_apply_delta_value), -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, "get_animable_value_names", VALUEFUNC(_wrap_AnimableObject_get_animable_value_names), -1);
  rb_define_method(SwigClassAnimableObject.klass, "create_animable_value", VALUEFUNC(_wrap_AnimableObject_create_animable_value), -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, "get_column", VALUEFUNC(_wrap_Matrix3_get_column), -1);
  rb_define_method(SwigClassMatrix3.klass, "set_column", VALUEFUNC(_wrap_Matrix3_set_column), -1);
  rb_define_method(SwigClassMatrix3.klass, "from_axes", VALUEFUNC(_wrap_Matrix3_from_axes), -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, "singular_value_decomposition", VALUEFUNC(_wrap_Matrix3_singular_value_decomposition), -1);
  rb_define_method(SwigClassMatrix3.klass, "singular_value_composition", VALUEFUNC(_wrap_Matrix3_singular_value_composition), -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, "spectral_norm", VALUEFUNC(_wrap_Matrix3_spectral_norm), -1);
  rb_define_method(SwigClassMatrix3.klass, "to_angle_axis", VALUEFUNC(_wrap_Matrix3_to_angle_axis), -1);
  rb_define_method(SwigClassMatrix3.klass, "from_angle_axis", VALUEFUNC(_wrap_Matrix3_from_angle_axis), -1);
  rb_define_method(SwigClassMatrix3.klass, "to_euler_angles_xyz", VALUEFUNC(_wrap_Matrix3_to_euler_angles_xyz), -1);
  rb_define_method(SwigClassMatrix3.klass, "to_euler_angles_xzy", VALUEFUNC(_wrap_Matrix3_to_euler_angles_xzy), -1);
  rb_define_method(SwigClassMatrix3.klass, "to_euler_angles_yxz", VALUEFUNC(_wrap_Matrix3_to_euler_angles_yxz), -1);
  rb_define_method(SwigClassMatrix3.klass, "to_euler_angles_yzx", VALUEFUNC(_wrap_Matrix3_to_euler_angles_yzx), -1);
  rb_define_method(SwigClassMatrix3.klass, "to_euler_angles_zxy", VALUEFUNC(_wrap_Matrix3_to_euler_angles_zxy), -1);
  rb_define_method(SwigClassMatrix3.klass, "to_euler_angles_zyx", VALUEFUNC(_wrap_Matrix3_to_euler_angles_zyx), -1);
  rb_define_method(SwigClassMatrix3.klass, "from_euler_angles_xyz", VALUEFUNC(_wrap_Matrix3_from_euler_angles_xyz), -1);
  rb_define_method(SwigClassMatrix3.klass, "from_euler_angles_xzy", VALUEFUNC(_wrap_Matrix3_from_euler_angles_xzy), -1);
  rb_define_method(SwigClassMatrix3.klass, "from_euler_angles_yxz", VALUEFUNC(_wrap_Matrix3_from_euler_angles_yxz), -1);
  rb_define_method(SwigClassMatrix3.klass, "from_euler_angles_yzx", VALUEFUNC(_wrap_Matrix3_from_euler_angles_yzx), -1);
  rb_define_method(SwigClassMatrix3.klass, "from_euler_angles_zxy", VALUEFUNC(_wrap_Matrix3_from_euler_angles_zxy), -1);
  rb_define_method(SwigClassMatrix3.klass, "from_euler_angles_zyx", VALUEFUNC(_wrap_Matrix3_from_euler_angles_zyx), -1);
  rb_define_method(SwigClassMatrix3.klass, "eigen_solve_symmetric", VALUEFUNC(_wrap_Matrix3_eigen_solve_symmetric), -1);
  rb_define_singleton_method(SwigClassMatrix3.klass, "tensor_product", VALUEFUNC(_wrap_Matrix3_tensor_product), -1);
  rb_define_method(SwigClassMatrix3.klass, "has_scale", VALUEFUNC(_wrap_Matrix3_has_scale), -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, "get_side", VALUEFUNC(_wrap_Plane_get_side), -1);
  rb_define_method(SwigClassPlane.klass, "get_distance", VALUEFUNC(_wrap_Plane_get_distance), -1);
  rb_define_method(SwigClassPlane.klass, "redefine", VALUEFUNC(_wrap_Plane_redefine), -1);
  rb_define_method(SwigClassPlane.klass, "project_vector", VALUEFUNC(_wrap_Plane_project_vector), -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, "set_trans", VALUEFUNC(_wrap_Matrix4_set_trans), -1);
  rb_define_method(SwigClassMatrix4.klass, "make_trans", VALUEFUNC(_wrap_Matrix4_make_trans), -1);
  rb_define_singleton_method(SwigClassMatrix4.klass, "get_trans", VALUEFUNC(_wrap_Matrix4_get_trans), -1);
  rb_define_method(SwigClassMatrix4.klass, "set_scale", VALUEFUNC(_wrap_Matrix4_set_scale), -1);
  rb_define_singleton_method(SwigClassMatrix4.klass, "get_scale", VALUEFUNC(_wrap_Matrix4_get_scale), -1);
  rb_define_method(SwigClassMatrix4.klass, "extract_3x_3matrix", VALUEFUNC(_wrap_Matrix4_extract_3x_3matrix), -1);
  rb_define_method(SwigClassMatrix4.klass, "has_scale", VALUEFUNC(_wrap_Matrix4_has_scale), -1);
  rb_define_method(SwigClassMatrix4.klass, "has_negative_scale", VALUEFUNC(_wrap_Matrix4_has_negative_scale), -1);
  rb_define_method(SwigClassMatrix4.klass, "extract_quaternion", VALUEFUNC(_wrap_Matrix4_extract_quaternion), -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, "make_transform", VALUEFUNC(_wrap_Matrix4_make_transform), -1);
  rb_define_method(SwigClassMatrix4.klass, "make_inverse_transform", VALUEFUNC(_wrap_Matrix4_make_inverse_transform), -1);
  rb_define_method(SwigClassMatrix4.klass, "decomposition", VALUEFUNC(_wrap_Matrix4_decomposition), -1);
  rb_define_method(SwigClassMatrix4.klass, "is_affine", VALUEFUNC(_wrap_Matrix4_is_affine), -1);
  rb_define_method(SwigClassMatrix4.klass, "inverse_affine", VALUEFUNC(_wrap_Matrix4_inverse_affine), -1);
  rb_define_method(SwigClassMatrix4.klass, "concatenate_affine", VALUEFUNC(_wrap_Matrix4_concatenate_affine), -1);
  rb_define_method(SwigClassMatrix4.klass, "transform_affine", VALUEFUNC(_wrap_Matrix4_transform_affine), -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, "add_point", VALUEFUNC(_wrap_SimpleSpline_add_point), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "get_point", VALUEFUNC(_wrap_SimpleSpline_get_point), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "get_num_points", VALUEFUNC(_wrap_SimpleSpline_get_num_points), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "clear", VALUEFUNC(_wrap_SimpleSpline_clear), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "update_point", VALUEFUNC(_wrap_SimpleSpline_update_point), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "interpolate", VALUEFUNC(_wrap_SimpleSpline_interpolate), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "set_auto_calculate", VALUEFUNC(_wrap_SimpleSpline_set_auto_calculate), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "recalc_tangents", VALUEFUNC(_wrap_SimpleSpline_recalc_tangents), -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, "add_point", VALUEFUNC(_wrap_RotationalSpline_add_point), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "get_point", VALUEFUNC(_wrap_RotationalSpline_get_point), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "get_num_points", VALUEFUNC(_wrap_RotationalSpline_get_num_points), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "clear", VALUEFUNC(_wrap_RotationalSpline_clear), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "update_point", VALUEFUNC(_wrap_RotationalSpline_update_point), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "interpolate", VALUEFUNC(_wrap_RotationalSpline_interpolate), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "set_auto_calculate", VALUEFUNC(_wrap_RotationalSpline_set_auto_calculate), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "recalc_tangents", VALUEFUNC(_wrap_RotationalSpline_recalc_tangents), -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, "read_data", VALUEFUNC(_wrap_HardwareBuffer_read_data), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "write_data", VALUEFUNC(_wrap_HardwareBuffer_write_data), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "copy_data", VALUEFUNC(_wrap_HardwareBuffer_copy_data), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "_update_from_shadow", VALUEFUNC(_wrap_HardwareBuffer__update_from_shadow), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "get_size_in_bytes", VALUEFUNC(_wrap_HardwareBuffer_get_size_in_bytes), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "get_usage", VALUEFUNC(_wrap_HardwareBuffer_get_usage), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "is_system_memory", VALUEFUNC(_wrap_HardwareBuffer_is_system_memory), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "has_shadow_buffer", VALUEFUNC(_wrap_HardwareBuffer_has_shadow_buffer), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "is_locked", VALUEFUNC(_wrap_HardwareBuffer_is_locked), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "suppress_hardware_update", VALUEFUNC(_wrap_HardwareBuffer_suppress_hardware_update), -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, "get_manager", VALUEFUNC(_wrap_HardwareVertexBuffer_get_manager), -1);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "get_vertex_size", VALUEFUNC(_wrap_HardwareVertexBuffer_get_vertex_size), -1);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "get_num_vertices", VALUEFUNC(_wrap_HardwareVertexBuffer_get_num_vertices), -1);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "get_is_instance_data", VALUEFUNC(_wrap_HardwareVertexBuffer_get_is_instance_data), -1);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "set_is_instance_data", VALUEFUNC(_wrap_HardwareVertexBuffer_set_is_instance_data), -1);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "get_instance_data_step_rate", VALUEFUNC(_wrap_HardwareVertexBuffer_get_instance_data_step_rate), -1);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "set_instance_data_step_rate", VALUEFUNC(_wrap_HardwareVertexBuffer_set_instance_data_step_rate), -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, "get_source", VALUEFUNC(_wrap_VertexElement_get_source), -1);
  rb_define_method(SwigClassVertexElement.klass, "get_offset", VALUEFUNC(_wrap_VertexElement_get_offset), -1);
  rb_define_method(SwigClassVertexElement.klass, "get_type", VALUEFUNC(_wrap_VertexElement_get_type), -1);
  rb_define_method(SwigClassVertexElement.klass, "get_semantic", VALUEFUNC(_wrap_VertexElement_get_semantic), -1);
  rb_define_method(SwigClassVertexElement.klass, "get_index", VALUEFUNC(_wrap_VertexElement_get_index), -1);
  rb_define_method(SwigClassVertexElement.klass, "get_size", VALUEFUNC(_wrap_VertexElement_get_size), -1);
  rb_define_singleton_method(SwigClassVertexElement.klass, "get_type_size", VALUEFUNC(_wrap_VertexElement_get_type_size), -1);
  rb_define_singleton_method(SwigClassVertexElement.klass, "get_type_count", VALUEFUNC(_wrap_VertexElement_get_type_count), -1);
  rb_define_singleton_method(SwigClassVertexElement.klass, "multiply_type_count", VALUEFUNC(_wrap_VertexElement_multiply_type_count), -1);
  rb_define_singleton_method(SwigClassVertexElement.klass, "get_base_type", VALUEFUNC(_wrap_VertexElement_get_base_type), -1);
  rb_define_singleton_method(SwigClassVertexElement.klass, "convert_colour_value", VALUEFUNC(_wrap_VertexElement_convert_colour_value), -1);
  rb_define_singleton_method(SwigClassVertexElement.klass, "get_best_colour_vertex_element_type", VALUEFUNC(_wrap_VertexElement_get_best_colour_vertex_element_type), -1);
  rb_define_method(SwigClassVertexElement.klass, "==", VALUEFUNC(_wrap_VertexElement___eq__), -1);
  rb_define_method(SwigClassVertexElement.klass, "base_vertex_pointer_to_element", VALUEFUNC(_wrap_VertexElement_base_vertex_pointer_to_element), -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, "vertex_element_less", VALUEFUNC(_wrap_VertexDeclaration_vertex_element_less), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "get_element_count", VALUEFUNC(_wrap_VertexDeclaration_get_element_count), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "get_elements", VALUEFUNC(_wrap_VertexDeclaration_get_elements), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "get_element", VALUEFUNC(_wrap_VertexDeclaration_get_element), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "sort", VALUEFUNC(_wrap_VertexDeclaration_sort), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "close_gaps_in_source", VALUEFUNC(_wrap_VertexDeclaration_close_gaps_in_source), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "get_auto_organised_declaration", VALUEFUNC(_wrap_VertexDeclaration_get_auto_organised_declaration), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "get_max_source", VALUEFUNC(_wrap_VertexDeclaration_get_max_source), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "add_element", VALUEFUNC(_wrap_VertexDeclaration_add_element), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "insert_element", VALUEFUNC(_wrap_VertexDeclaration_insert_element), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "remove_element", VALUEFUNC(_wrap_VertexDeclaration_remove_element), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "remove_all_elements", VALUEFUNC(_wrap_VertexDeclaration_remove_all_elements), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "modify_element", VALUEFUNC(_wrap_VertexDeclaration_modify_element), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "find_element_by_semantic", VALUEFUNC(_wrap_VertexDeclaration_find_element_by_semantic), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "find_elements_by_source", VALUEFUNC(_wrap_VertexDeclaration_find_elements_by_source), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "get_vertex_size", VALUEFUNC(_wrap_VertexDeclaration_get_vertex_size), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "get_next_free_texture_coordinate", VALUEFUNC(_wrap_VertexDeclaration_get_next_free_texture_coordinate), -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, "set_binding", VALUEFUNC(_wrap_VertexBufferBinding_set_binding), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "unset_binding", VALUEFUNC(_wrap_VertexBufferBinding_unset_binding), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "unset_all_bindings", VALUEFUNC(_wrap_VertexBufferBinding_unset_all_bindings), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "get_bindings", VALUEFUNC(_wrap_VertexBufferBinding_get_bindings), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "get_buffer", VALUEFUNC(_wrap_VertexBufferBinding_get_buffer), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "is_buffer_bound", VALUEFUNC(_wrap_VertexBufferBinding_is_buffer_bound), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "get_buffer_count", VALUEFUNC(_wrap_VertexBufferBinding_get_buffer_count), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "get_next_index", VALUEFUNC(_wrap_VertexBufferBinding_get_next_index), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "get_last_bound_index", VALUEFUNC(_wrap_VertexBufferBinding_get_last_bound_index), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "has_gaps", VALUEFUNC(_wrap_VertexBufferBinding_has_gaps), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "close_gaps", VALUEFUNC(_wrap_VertexBufferBinding_close_gaps), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "get_has_instance_data", VALUEFUNC(_wrap_VertexBufferBinding_get_has_instance_data), -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, "get_time", VALUEFUNC(_wrap_KeyFrame_get_time), -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, "get_value", VALUEFUNC(_wrap_NumericKeyFrame_get_value), -1);
  rb_define_method(SwigClassNumericKeyFrame.klass, "set_value", VALUEFUNC(_wrap_NumericKeyFrame_set_value), -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, "set_translate", VALUEFUNC(_wrap_TransformKeyFrame_set_translate), -1);
  rb_define_method(SwigClassTransformKeyFrame.klass, "get_translate", VALUEFUNC(_wrap_TransformKeyFrame_get_translate), -1);
  rb_define_method(SwigClassTransformKeyFrame.klass, "set_scale", VALUEFUNC(_wrap_TransformKeyFrame_set_scale), -1);
  rb_define_method(SwigClassTransformKeyFrame.klass, "get_scale", VALUEFUNC(_wrap_TransformKeyFrame_get_scale), -1);
  rb_define_method(SwigClassTransformKeyFrame.klass, "set_rotation", VALUEFUNC(_wrap_TransformKeyFrame_set_rotation), -1);
  rb_define_method(SwigClassTransformKeyFrame.klass, "get_rotation", VALUEFUNC(_wrap_TransformKeyFrame_get_rotation), -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, "set_vertex_buffer", VALUEFUNC(_wrap_VertexMorphKeyFrame_set_vertex_buffer), -1);
  rb_define_method(SwigClassVertexMorphKeyFrame.klass, "get_vertex_buffer", VALUEFUNC(_wrap_VertexMorphKeyFrame_get_vertex_buffer), -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, "add_pose_reference", VALUEFUNC(_wrap_VertexPoseKeyFrame_add_pose_reference), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "update_pose_reference", VALUEFUNC(_wrap_VertexPoseKeyFrame_update_pose_reference), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "remove_pose_reference", VALUEFUNC(_wrap_VertexPoseKeyFrame_remove_pose_reference), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "remove_all_pose_references", VALUEFUNC(_wrap_VertexPoseKeyFrame_remove_all_pose_references), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "get_pose_references", VALUEFUNC(_wrap_VertexPoseKeyFrame_get_pose_references), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "get_pose_reference_iterator", VALUEFUNC(_wrap_VertexPoseKeyFrame_get_pose_reference_iterator), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "_clone", VALUEFUNC(_wrap_VertexPoseKeyFrame__clone), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "_apply_base_key_frame", VALUEFUNC(_wrap_VertexPoseKeyFrame__apply_base_key_frame), -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, "get_name", VALUEFUNC(_wrap_Pose_get_name), -1);
  rb_define_method(SwigClassPose.klass, "get_target", VALUEFUNC(_wrap_Pose_get_target), -1);
  rb_define_method(SwigClassPose.klass, "get_includes_normals", VALUEFUNC(_wrap_Pose_get_includes_normals), -1);
  rb_define_method(SwigClassPose.klass, "add_vertex", VALUEFUNC(_wrap_Pose_add_vertex), -1);
  rb_define_method(SwigClassPose.klass, "remove_vertex", VALUEFUNC(_wrap_Pose_remove_vertex), -1);
  rb_define_method(SwigClassPose.klass, "clear_vertices", VALUEFUNC(_wrap_Pose_clear_vertices), -1);
  rb_define_method(SwigClassPose.klass, "get_vertex_offset_iterator", VALUEFUNC(_wrap_Pose_get_vertex_offset_iterator), -1);
  rb_define_method(SwigClassPose.klass, "get_vertex_offsets", VALUEFUNC(_wrap_Pose_get_vertex_offsets), -1);
  rb_define_method(SwigClassPose.klass, "get_normals_iterator", VALUEFUNC(_wrap_Pose_get_normals_iterator), -1);
  rb_define_method(SwigClassPose.klass, "get_normals", VALUEFUNC(_wrap_Pose_get_normals), -1);
  rb_define_method(SwigClassPose.klass, "_get_hardware_vertex_buffer", VALUEFUNC(_wrap_Pose__get_hardware_vertex_buffer), -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, "has_key_index", VALUEFUNC(_wrap_TimeIndex_has_key_index), -1);
  rb_define_method(SwigClassTimeIndex.klass, "get_time_pos", VALUEFUNC(_wrap_TimeIndex_get_time_pos), -1);
  rb_define_method(SwigClassTimeIndex.klass, "get_key_index", VALUEFUNC(_wrap_TimeIndex_get_key_index), -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, "get_handle", VALUEFUNC(_wrap_AnimationTrack_get_handle), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "get_num_key_frames", VALUEFUNC(_wrap_AnimationTrack_get_num_key_frames), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "get_key_frame", VALUEFUNC(_wrap_AnimationTrack_get_key_frame), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "get_key_frames_at_time", VALUEFUNC(_wrap_AnimationTrack_get_key_frames_at_time), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "create_key_frame", VALUEFUNC(_wrap_AnimationTrack_create_key_frame), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "remove_key_frame", VALUEFUNC(_wrap_AnimationTrack_remove_key_frame), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "remove_all_key_frames", VALUEFUNC(_wrap_AnimationTrack_remove_all_key_frames), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "get_interpolated_key_frame", VALUEFUNC(_wrap_AnimationTrack_get_interpolated_key_frame), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "apply", VALUEFUNC(_wrap_AnimationTrack_apply), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "_key_frame_data_changed", VALUEFUNC(_wrap_AnimationTrack__key_frame_data_changed), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "has_non_zero_key_frames", VALUEFUNC(_wrap_AnimationTrack_has_non_zero_key_frames), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "optimise", VALUEFUNC(_wrap_AnimationTrack_optimise), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "_collect_key_frame_times", VALUEFUNC(_wrap_AnimationTrack__collect_key_frame_times), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "_build_key_frame_index_map", VALUEFUNC(_wrap_AnimationTrack__build_key_frame_index_map), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "_apply_base_key_frame", VALUEFUNC(_wrap_AnimationTrack__apply_base_key_frame), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "set_listener", VALUEFUNC(_wrap_AnimationTrack_set_listener), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "get_parent", VALUEFUNC(_wrap_AnimationTrack_get_parent), -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, "create_numeric_key_frame", VALUEFUNC(_wrap_NumericAnimationTrack_create_numeric_key_frame), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "get_interpolated_key_frame", VALUEFUNC(_wrap_NumericAnimationTrack_get_interpolated_key_frame), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "apply", VALUEFUNC(_wrap_NumericAnimationTrack_apply), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "apply_to_animable", VALUEFUNC(_wrap_NumericAnimationTrack_apply_to_animable), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "get_associated_animable", VALUEFUNC(_wrap_NumericAnimationTrack_get_associated_animable), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "set_associated_animable", VALUEFUNC(_wrap_NumericAnimationTrack_set_associated_animable), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "get_numeric_key_frame", VALUEFUNC(_wrap_NumericAnimationTrack_get_numeric_key_frame), -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, "create_node_key_frame", VALUEFUNC(_wrap_NodeAnimationTrack_create_node_key_frame), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "get_associated_node", VALUEFUNC(_wrap_NodeAnimationTrack_get_associated_node), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "set_associated_node", VALUEFUNC(_wrap_NodeAnimationTrack_set_associated_node), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "apply_to_node", VALUEFUNC(_wrap_NodeAnimationTrack_apply_to_node), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "set_use_shortest_rotation_path", VALUEFUNC(_wrap_NodeAnimationTrack_set_use_shortest_rotation_path), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "get_use_shortest_rotation_path", VALUEFUNC(_wrap_NodeAnimationTrack_get_use_shortest_rotation_path), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "get_interpolated_key_frame", VALUEFUNC(_wrap_NodeAnimationTrack_get_interpolated_key_frame), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "apply", VALUEFUNC(_wrap_NodeAnimationTrack_apply), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "_key_frame_data_changed", VALUEFUNC(_wrap_NodeAnimationTrack__key_frame_data_changed), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "get_node_key_frame", VALUEFUNC(_wrap_NodeAnimationTrack_get_node_key_frame), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "has_non_zero_key_frames", VALUEFUNC(_wrap_NodeAnimationTrack_has_non_zero_key_frames), -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, "_apply_base_key_frame", VALUEFUNC(_wrap_NodeAnimationTrack__apply_base_key_frame), -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, "get_animation_type", VALUEFUNC(_wrap_VertexAnimationTrack_get_animation_type), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "get_vertex_animation_includes_normals", VALUEFUNC(_wrap_VertexAnimationTrack_get_vertex_animation_includes_normals), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "create_vertex_morph_key_frame", VALUEFUNC(_wrap_VertexAnimationTrack_create_vertex_morph_key_frame), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "create_vertex_pose_key_frame", VALUEFUNC(_wrap_VertexAnimationTrack_create_vertex_pose_key_frame), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "get_interpolated_key_frame", VALUEFUNC(_wrap_VertexAnimationTrack_get_interpolated_key_frame), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "apply", VALUEFUNC(_wrap_VertexAnimationTrack_apply), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "apply_to_vertex_data", VALUEFUNC(_wrap_VertexAnimationTrack_apply_to_vertex_data), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "get_vertex_morph_key_frame", VALUEFUNC(_wrap_VertexAnimationTrack_get_vertex_morph_key_frame), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "get_vertex_pose_key_frame", VALUEFUNC(_wrap_VertexAnimationTrack_get_vertex_pose_key_frame), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "set_associated_vertex_data", VALUEFUNC(_wrap_VertexAnimationTrack_set_associated_vertex_data), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "get_associated_vertex_data", VALUEFUNC(_wrap_VertexAnimationTrack_get_associated_vertex_data), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "set_target_mode", VALUEFUNC(_wrap_VertexAnimationTrack_set_target_mode), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "get_target_mode", VALUEFUNC(_wrap_VertexAnimationTrack_get_target_mode), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "has_non_zero_key_frames", VALUEFUNC(_wrap_VertexAnimationTrack_has_non_zero_key_frames), -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, "_apply_base_key_frame", VALUEFUNC(_wrap_VertexAnimationTrack__apply_base_key_frame), -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, "get_animation_name", VALUEFUNC(_wrap_AnimationState_get_animation_name), -1);
  rb_define_method(SwigClassAnimationState.klass, "get_time_position", VALUEFUNC(_wrap_AnimationState_get_time_position), -1);
  rb_define_method(SwigClassAnimationState.klass, "set_time_position", VALUEFUNC(_wrap_AnimationState_set_time_position), -1);
  rb_define_method(SwigClassAnimationState.klass, "get_length", VALUEFUNC(_wrap_AnimationState_get_length), -1);
  rb_define_method(SwigClassAnimationState.klass, "set_length", VALUEFUNC(_wrap_AnimationState_set_length), -1);
  rb_define_method(SwigClassAnimationState.klass, "get_weight", VALUEFUNC(_wrap_AnimationState_get_weight), -1);
  rb_define_method(SwigClassAnimationState.klass, "set_weight", VALUEFUNC(_wrap_AnimationState_set_weight), -1);
  rb_define_method(SwigClassAnimationState.klass, "add_time", VALUEFUNC(_wrap_AnimationState_add_time), -1);
  rb_define_method(SwigClassAnimationState.klass, "has_ended", VALUEFUNC(_wrap_AnimationState_has_ended), -1);
  rb_define_method(SwigClassAnimationState.klass, "get_enabled", VALUEFUNC(_wrap_AnimationState_get_enabled), -1);
  rb_define_method(SwigClassAnimationState.klass, "set_enabled", VALUEFUNC(_wrap_AnimationState_set_enabled), -1);
  rb_define_method(SwigClassAnimationState.klass, "==", VALUEFUNC(_wrap_AnimationState___eq__), -1);
  rb_define_method(SwigClassAnimationState.klass, "set_loop", VALUEFUNC(_wrap_AnimationState_set_loop), -1);
  rb_define_method(SwigClassAnimationState.klass, "get_loop", VALUEFUNC(_wrap_AnimationState_get_loop), -1);
  rb_define_method(SwigClassAnimationState.klass, "copy_state_from", VALUEFUNC(_wrap_AnimationState_copy_state_from), -1);
  rb_define_method(SwigClassAnimationState.klass, "get_parent", VALUEFUNC(_wrap_AnimationState_get_parent), -1);
  rb_define_method(SwigClassAnimationState.klass, "create_blend_mask", VALUEFUNC(_wrap_AnimationState_create_blend_mask), -1);
  rb_define_method(SwigClassAnimationState.klass, "destroy_blend_mask", VALUEFUNC(_wrap_AnimationState_destroy_blend_mask), -1);
  rb_define_method(SwigClassAnimationState.klass, "_set_blend_mask_data", VALUEFUNC(_wrap_AnimationState__set_blend_mask_data), -1);
  rb_define_method(SwigClassAnimationState.klass, "_set_blend_mask", VALUEFUNC(_wrap_AnimationState__set_blend_mask), -1);
  rb_define_method(SwigClassAnimationState.klass, "get_blend_mask", VALUEFUNC(_wrap_AnimationState_get_blend_mask), -1);
  rb_define_method(SwigClassAnimationState.klass, "has_blend_mask", VALUEFUNC(_wrap_AnimationState_has_blend_mask), -1);
  rb_define_method(SwigClassAnimationState.klass, "set_blend_mask_entry", VALUEFUNC(_wrap_AnimationState_set_blend_mask_entry), -1);
  rb_define_method(SwigClassAnimationState.klass, "get_blend_mask_entry", VALUEFUNC(_wrap_AnimationState_get_blend_mask_entry), -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, "create_animation_state", VALUEFUNC(_wrap_AnimationStateSet_create_animation_state), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "get_animation_state", VALUEFUNC(_wrap_AnimationStateSet_get_animation_state), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "has_animation_state", VALUEFUNC(_wrap_AnimationStateSet_has_animation_state), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "remove_animation_state", VALUEFUNC(_wrap_AnimationStateSet_remove_animation_state), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "remove_all_animation_states", VALUEFUNC(_wrap_AnimationStateSet_remove_all_animation_states), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "get_animation_state_iterator", VALUEFUNC(_wrap_AnimationStateSet_get_animation_state_iterator), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "copy_matching_state", VALUEFUNC(_wrap_AnimationStateSet_copy_matching_state), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "_notify_dirty", VALUEFUNC(_wrap_AnimationStateSet__notify_dirty), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "get_dirty_frame_number", VALUEFUNC(_wrap_AnimationStateSet_get_dirty_frame_number), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "_notify_animation_state_enabled", VALUEFUNC(_wrap_AnimationStateSet__notify_animation_state_enabled), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "has_enabled_animation_state", VALUEFUNC(_wrap_AnimationStateSet_has_enabled_animation_state), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "get_enabled_animation_state_iterator", VALUEFUNC(_wrap_AnimationStateSet_get_enabled_animation_state_iterator), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "each_animation_state", VALUEFUNC(_wrap_AnimationStateSet_each_animation_state), -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, "get_value", VALUEFUNC(_wrap_AnimationStateControllerValue_get_value), -1);
  rb_define_method(SwigClassAnimationStateControllerValue.klass, "set_value", VALUEFUNC(_wrap_AnimationStateControllerValue_set_value), -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, "get_num_animations", VALUEFUNC(_wrap_AnimationContainer_get_num_animations), -1);
  rb_define_method(SwigClassAnimationContainer.klass, "get_animation", VALUEFUNC(_wrap_AnimationContainer_get_animation), -1);
  rb_define_method(SwigClassAnimationContainer.klass, "create_animation", VALUEFUNC(_wrap_AnimationContainer_create_animation), -1);
  rb_define_method(SwigClassAnimationContainer.klass, "has_animation", VALUEFUNC(_wrap_AnimationContainer_has_animation), -1);
  rb_define_method(SwigClassAnimationContainer.klass, "remove_animation", VALUEFUNC(_wrap_AnimationContainer_remove_animation), -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, "get_name", VALUEFUNC(_wrap_Animation_get_name), -1);
  rb_define_method(SwigClassAnimation.klass, "get_length", VALUEFUNC(_wrap_Animation_get_length), -1);
  rb_define_method(SwigClassAnimation.klass, "set_length", VALUEFUNC(_wrap_Animation_set_length), -1);
  rb_define_method(SwigClassAnimation.klass, "create_node_track", VALUEFUNC(_wrap_Animation_create_node_track), -1);
  rb_define_method(SwigClassAnimation.klass, "create_numeric_track", VALUEFUNC(_wrap_Animation_create_numeric_track), -1);
  rb_define_method(SwigClassAnimation.klass, "create_vertex_track", VALUEFUNC(_wrap_Animation_create_vertex_track), -1);
  rb_define_method(SwigClassAnimation.klass, "get_num_node_tracks", VALUEFUNC(_wrap_Animation_get_num_node_tracks), -1);
  rb_define_method(SwigClassAnimation.klass, "get_node_track", VALUEFUNC(_wrap_Animation_get_node_track), -1);
  rb_define_method(SwigClassAnimation.klass, "has_node_track", VALUEFUNC(_wrap_Animation_has_node_track), -1);
  rb_define_method(SwigClassAnimation.klass, "get_num_numeric_tracks", VALUEFUNC(_wrap_Animation_get_num_numeric_tracks), -1);
  rb_define_method(SwigClassAnimation.klass, "get_numeric_track", VALUEFUNC(_wrap_Animation_get_numeric_track), -1);
  rb_define_method(SwigClassAnimation.klass, "has_numeric_track", VALUEFUNC(_wrap_Animation_has_numeric_track), -1);
  rb_define_method(SwigClassAnimation.klass, "get_num_vertex_tracks", VALUEFUNC(_wrap_Animation_get_num_vertex_tracks), -1);
  rb_define_method(SwigClassAnimation.klass, "get_vertex_track", VALUEFUNC(_wrap_Animation_get_vertex_track), -1);
  rb_define_method(SwigClassAnimation.klass, "has_vertex_track", VALUEFUNC(_wrap_Animation_has_vertex_track), -1);
  rb_define_method(SwigClassAnimation.klass, "destroy_node_track", VALUEFUNC(_wrap_Animation_destroy_node_track), -1);
  rb_define_method(SwigClassAnimation.klass, "destroy_numeric_track", VALUEFUNC(_wrap_Animation_destroy_numeric_track), -1);
  rb_define_method(SwigClassAnimation.klass, "destroy_vertex_track", VALUEFUNC(_wrap_Animation_destroy_vertex_track), -1);
  rb_define_method(SwigClassAnimation.klass, "destroy_all_tracks", VALUEFUNC(_wrap_Animation_destroy_all_tracks), -1);
  rb_define_method(SwigClassAnimation.klass, "destroy_all_node_tracks", VALUEFUNC(_wrap_Animation_destroy_all_node_tracks), -1);
  rb_define_method(SwigClassAnimation.klass, "destroy_all_numeric_tracks", VALUEFUNC(_wrap_Animation_destroy_all_numeric_tracks), -1);
  rb_define_method(SwigClassAnimation.klass, "destroy_all_vertex_tracks", VALUEFUNC(_wrap_Animation_destroy_all_vertex_tracks), -1);
  rb_define_method(SwigClassAnimation.klass, "apply_to_node", VALUEFUNC(_wrap_Animation_apply_to_node), -1);
  rb_define_method(SwigClassAnimation.klass, "apply", VALUEFUNC(_wrap_Animation_apply), -1);
  rb_define_method(SwigClassAnimation.klass, "apply_to_animable", VALUEFUNC(_wrap_Animation_apply_to_animable), -1);
  rb_define_method(SwigClassAnimation.klass, "apply_to_vertex_data", VALUEFUNC(_wrap_Animation_apply_to_vertex_data), -1);
  rb_define_method(SwigClassAnimation.klass, "set_interpolation_mode", VALUEFUNC(_wrap_Animation_set_interpolation_mode), -1);
  rb_define_method(SwigClassAnimation.klass, "get_interpolation_mode", VALUEFUNC(_wrap_Animation_get_interpolation_mode), -1);
  rb_define_method(SwigClassAnimation.klass, "set_rotation_interpolation_mode", VALUEFUNC(_wrap_Animation_set_rotation_interpolation_mode), -1);
  rb_define_method(SwigClassAnimation.klass, "get_rotation_interpolation_mode", VALUEFUNC(_wrap_Animation_get_rotation_interpolation_mode), -1);
  rb_define_singleton_method(SwigClassAnimation.klass, "set_default_interpolation_mode", VALUEFUNC(_wrap_Animation_set_default_interpolation_mode), -1);
  rb_define_singleton_method(SwigClassAnimation.klass, "get_default_interpolation_mode", VALUEFUNC(_wrap_Animation_get_default_interpolation_mode), -1);
  rb_define_singleton_method(SwigClassAnimation.klass, "set_default_rotation_interpolation_mode", VALUEFUNC(_wrap_Animation_set_default_rotation_interpolation_mode), -1);
  rb_define_singleton_method(SwigClassAnimation.klass, "get_default_rotation_interpolation_mode", VALUEFUNC(_wrap_Animation_get_default_rotation_interpolation_mode), -1);
  rb_define_method(SwigClassAnimation.klass, "_get_node_track_list", VALUEFUNC(_wrap_Animation__get_node_track_list), -1);
  rb_define_method(SwigClassAnimation.klass, "get_node_track_iterator", VALUEFUNC(_wrap_Animation_get_node_track_iterator), -1);
  rb_define_method(SwigClassAnimation.klass, "_get_numeric_track_list", VALUEFUNC(_wrap_Animation__get_numeric_track_list), -1);
  rb_define_method(SwigClassAnimation.klass, "get_numeric_track_iterator", VALUEFUNC(_wrap_Animation_get_numeric_track_iterator), -1);
  rb_define_method(SwigClassAnimation.klass, "_get_vertex_track_list", VALUEFUNC(_wrap_Animation__get_vertex_track_list), -1);
  rb_define_method(SwigClassAnimation.klass, "get_vertex_track_iterator", VALUEFUNC(_wrap_Animation_get_vertex_track_iterator), -1);
  rb_define_method(SwigClassAnimation.klass, "optimise", VALUEFUNC(_wrap_Animation_optimise), -1);
  rb_define_method(SwigClassAnimation.klass, "_collect_identity_node_tracks", VALUEFUNC(_wrap_Animation__collect_identity_node_tracks), -1);
  rb_define_method(SwigClassAnimation.klass, "_destroy_node_tracks", VALUEFUNC(_wrap_Animation__destroy_node_tracks), -1);
  rb_define_method(SwigClassAnimation.klass, "clone", VALUEFUNC(_wrap_Animation_clone), -1);
  rb_define_method(SwigClassAnimation.klass, "_key_frame_list_changed", VALUEFUNC(_wrap_Animation__key_frame_list_changed), -1);
  rb_define_method(SwigClassAnimation.klass, "_get_time_index", VALUEFUNC(_wrap_Animation__get_time_index), -1);
  rb_define_method(SwigClassAnimation.klass, "set_use_base_key_frame", VALUEFUNC(_wrap_Animation_set_use_base_key_frame), -1);
  rb_define_method(SwigClassAnimation.klass, "get_use_base_key_frame", VALUEFUNC(_wrap_Animation_get_use_base_key_frame), -1);
  rb_define_method(SwigClassAnimation.klass, "get_base_key_frame_time", VALUEFUNC(_wrap_Animation_get_base_key_frame_time), -1);
  rb_define_method(SwigClassAnimation.klass, "get_base_key_frame_animation_name", VALUEFUNC(_wrap_Animation_get_base_key_frame_animation_name), -1);
  rb_define_method(SwigClassAnimation.klass, "_apply_base_key_frame", VALUEFUNC(_wrap_Animation__apply_base_key_frame), -1);
  rb_define_method(SwigClassAnimation.klass, "_notify_container", VALUEFUNC(_wrap_Animation__notify_container), -1);
  rb_define_method(SwigClassAnimation.klass, "get_container", VALUEFUNC(_wrap_Animation_get_container), -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, "get_name", VALUEFUNC(_wrap_DataStream_get_name), -1);
  rb_define_method(SwigClassDataStream.klass, "get_access_mode", VALUEFUNC(_wrap_DataStream_get_access_mode), -1);
  rb_define_method(SwigClassDataStream.klass, "is_readable", VALUEFUNC(_wrap_DataStream_is_readable), -1);
  rb_define_method(SwigClassDataStream.klass, "is_writeable", VALUEFUNC(_wrap_DataStream_is_writeable), -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, "read_line", VALUEFUNC(_wrap_DataStream_read_line), -1);
  rb_define_method(SwigClassDataStream.klass, "get_line", VALUEFUNC(_wrap_DataStream_get_line), -1);
  rb_define_method(SwigClassDataStream.klass, "get_as_string", VALUEFUNC(_wrap_DataStream_get_as_string), -1);
  rb_define_method(SwigClassDataStream.klass, "skip_line", VALUEFUNC(_wrap_DataStream_skip_line), -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, "get_ptr", VALUEFUNC(_wrap_MemoryDataStream_get_ptr), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "get_current_ptr", VALUEFUNC(_wrap_MemoryDataStream_get_current_ptr), -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, "read_line", VALUEFUNC(_wrap_MemoryDataStream_read_line), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "skip_line", VALUEFUNC(_wrap_MemoryDataStream_skip_line), -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, "set_free_on_close", VALUEFUNC(_wrap_MemoryDataStream_set_free_on_close), -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, "read_line", VALUEFUNC(_wrap_FileStreamDataStream_read_line), -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, "get_name", VALUEFUNC(_wrap_Archive_get_name), -1);
  rb_define_method(SwigClassArchive.klass, "is_case_sensitive", VALUEFUNC(_wrap_Archive_is_case_sensitive), -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, "is_read_only", VALUEFUNC(_wrap_Archive_is_read_only), -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, "list_file_info", VALUEFUNC(_wrap_Archive_list_file_info), -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, "get_modified_time", VALUEFUNC(_wrap_Archive_get_modified_time), -1);
  rb_define_method(SwigClassArchive.klass, "find_file_info", VALUEFUNC(_wrap_Archive_find_file_info), -1);
  rb_define_method(SwigClassArchive.klass, "get_type", VALUEFUNC(_wrap_Archive_get_type), -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, "fast_hash", VALUEFUNC(_wrap_fast_hash), -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, "get_width", VALUEFUNC(_wrap_Box_get_width), -1);
  rb_define_method(SwigClassBox.klass, "get_height", VALUEFUNC(_wrap_Box_get_height), -1);
  rb_define_method(SwigClassBox.klass, "get_depth", VALUEFUNC(_wrap_Box_get_depth), -1);
  SwigClassBox.mark = 0;
  SwigClassBox.destroy = (void (*)(void *)) free_Ogre_Box;
  SwigClassBox.trackObjects = 0;
  rb_define_module_function(mOgre, "find_command_line_opts", VALUEFUNC(_wrap_find_command_line_opts), -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, "set_next", VALUEFUNC(_wrap_NameGenerator_set_next), -1);
  rb_define_method(SwigClassNameGenerator.klass, "get_next", VALUEFUNC(_wrap_NameGenerator_get_next), -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, "do_get", VALUEFUNC(_wrap_ParamCommand_do_get), -1);
  rb_define_method(SwigClassParamCommand.klass, "do_set", VALUEFUNC(_wrap_ParamCommand_do_set), -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, "add_parameter", VALUEFUNC(_wrap_ParamDictionary_add_parameter), -1);
  rb_define_method(SwigClassParamDictionary.klass, "get_parameters", VALUEFUNC(_wrap_ParamDictionary_get_parameters), -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, "get_param_dictionary", VALUEFUNC(_wrap_StringInterface_get_param_dictionary), -1);
  rb_define_method(SwigClassStringInterface.klass, "get_parameters", VALUEFUNC(_wrap_StringInterface_get_parameters), -1);
  rb_define_method(SwigClassStringInterface.klass, "set_parameter", VALUEFUNC(_wrap_StringInterface_set_parameter), -1);
  rb_define_method(SwigClassStringInterface.klass, "set_parameter_list", VALUEFUNC(_wrap_StringInterface_set_parameter_list), -1);
  rb_define_method(SwigClassStringInterface.klass, "get_parameter", VALUEFUNC(_wrap_StringInterface_get_parameter), -1);
  rb_define_method(SwigClassStringInterface.klass, "copy_parameters_to", VALUEFUNC(_wrap_StringInterface_copy_parameters_to), -1);
  rb_define_singleton_method(SwigClassStringInterface.klass, "cleanup_dictionary", VALUEFUNC(_wrap_StringInterface_cleanup_dictionary), -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, "use_count", VALUEFUNC(_wrap_ResourceSharedPtr_use_count), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "use_count_pointer", VALUEFUNC(_wrap_ResourceSharedPtr_use_count_pointer), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get_pointer", VALUEFUNC(_wrap_ResourceSharedPtr_get_pointer), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "free_method", VALUEFUNC(_wrap_ResourceSharedPtr_free_method), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "is_null", VALUEFUNC(_wrap_ResourceSharedPtr_is_null), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "set_null", VALUEFUNC(_wrap_ResourceSharedPtr_set_null), -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, "is_reloadable", VALUEFUNC(_wrap_ResourceSharedPtr_is_reloadable), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "is_manually_loaded", VALUEFUNC(_wrap_ResourceSharedPtr_is_manually_loaded), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "unload", VALUEFUNC(_wrap_ResourceSharedPtr_unload), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get_size", VALUEFUNC(_wrap_ResourceSharedPtr_get_size), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "touch", VALUEFUNC(_wrap_ResourceSharedPtr_touch), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get_name", VALUEFUNC(_wrap_ResourceSharedPtr_get_name), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get_handle", VALUEFUNC(_wrap_ResourceSharedPtr_get_handle), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "is_prepared", VALUEFUNC(_wrap_ResourceSharedPtr_is_prepared), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "is_loaded", VALUEFUNC(_wrap_ResourceSharedPtr_is_loaded), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "is_loading", VALUEFUNC(_wrap_ResourceSharedPtr_is_loading), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get_loading_state", VALUEFUNC(_wrap_ResourceSharedPtr_get_loading_state), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "is_background_loaded", VALUEFUNC(_wrap_ResourceSharedPtr_is_background_loaded), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "set_background_loaded", VALUEFUNC(_wrap_ResourceSharedPtr_set_background_loaded), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "escalate_loading", VALUEFUNC(_wrap_ResourceSharedPtr_escalate_loading), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "add_listener", VALUEFUNC(_wrap_ResourceSharedPtr_add_listener), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "remove_listener", VALUEFUNC(_wrap_ResourceSharedPtr_remove_listener), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get_group", VALUEFUNC(_wrap_ResourceSharedPtr_get_group), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "change_group_ownership", VALUEFUNC(_wrap_ResourceSharedPtr_change_group_ownership), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get_creator", VALUEFUNC(_wrap_ResourceSharedPtr_get_creator), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get_origin", VALUEFUNC(_wrap_ResourceSharedPtr_get_origin), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "_notify_origin", VALUEFUNC(_wrap_ResourceSharedPtr__notify_origin), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get_state_count", VALUEFUNC(_wrap_ResourceSharedPtr_get_state_count), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "_dirty_state", VALUEFUNC(_wrap_ResourceSharedPtr__dirty_state), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "_fire_loading_complete", VALUEFUNC(_wrap_ResourceSharedPtr__fire_loading_complete), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "_fire_preparing_complete", VALUEFUNC(_wrap_ResourceSharedPtr__fire_preparing_complete), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "_fire_unloading_complete", VALUEFUNC(_wrap_ResourceSharedPtr__fire_unloading_complete), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get_param_dictionary", VALUEFUNC(_wrap_ResourceSharedPtr_get_param_dictionary), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get_parameters", VALUEFUNC(_wrap_ResourceSharedPtr_get_parameters), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "set_parameter", VALUEFUNC(_wrap_ResourceSharedPtr_set_parameter), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "set_parameter_list", VALUEFUNC(_wrap_ResourceSharedPtr_set_parameter_list), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get_parameter", VALUEFUNC(_wrap_ResourceSharedPtr_get_parameter), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "copy_parameters_to", VALUEFUNC(_wrap_ResourceSharedPtr_copy_parameters_to), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "cleanup_dictionary", VALUEFUNC(_wrap_ResourceSharedPtr_cleanup_dictionary), -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, "is_reloadable", VALUEFUNC(_wrap_Resource_is_reloadable), -1);
  rb_define_method(SwigClassResource.klass, "is_manually_loaded", VALUEFUNC(_wrap_Resource_is_manually_loaded), -1);
  rb_define_method(SwigClassResource.klass, "unload", VALUEFUNC(_wrap_Resource_unload), -1);
  rb_define_method(SwigClassResource.klass, "get_size", VALUEFUNC(_wrap_Resource_get_size), -1);
  rb_define_method(SwigClassResource.klass, "touch", VALUEFUNC(_wrap_Resource_touch), -1);
  rb_define_method(SwigClassResource.klass, "get_name", VALUEFUNC(_wrap_Resource_get_name), -1);
  rb_define_method(SwigClassResource.klass, "get_handle", VALUEFUNC(_wrap_Resource_get_handle), -1);
  rb_define_method(SwigClassResource.klass, "is_prepared", VALUEFUNC(_wrap_Resource_is_prepared), -1);
  rb_define_method(SwigClassResource.klass, "is_loaded", VALUEFUNC(_wrap_Resource_is_loaded), -1);
  rb_define_method(SwigClassResource.klass, "is_loading", VALUEFUNC(_wrap_Resource_is_loading), -1);
  rb_define_method(SwigClassResource.klass, "get_loading_state", VALUEFUNC(_wrap_Resource_get_loading_state), -1);
  rb_define_method(SwigClassResource.klass, "is_background_loaded", VALUEFUNC(_wrap_Resource_is_background_loaded), -1);
  rb_define_method(SwigClassResource.klass, "set_background_loaded", VALUEFUNC(_wrap_Resource_set_background_loaded), -1);
  rb_define_method(SwigClassResource.klass, "escalate_loading", VALUEFUNC(_wrap_Resource_escalate_loading), -1);
  rb_define_method(SwigClassResource.klass, "add_listener", VALUEFUNC(_wrap_Resource_add_listener), -1);
  rb_define_method(SwigClassResource.klass, "remove_listener", VALUEFUNC(_wrap_Resource_remove_listener), -1);
  rb_define_method(SwigClassResource.klass, "get_group", VALUEFUNC(_wrap_Resource_get_group), -1);
  rb_define_method(SwigClassResource.klass, "change_group_ownership", VALUEFUNC(_wrap_Resource_change_group_ownership), -1);
  rb_define_method(SwigClassResource.klass, "get_creator", VALUEFUNC(_wrap_Resource_get_creator), -1);
  rb_define_method(SwigClassResource.klass, "get_origin", VALUEFUNC(_wrap_Resource_get_origin), -1);
  rb_define_method(SwigClassResource.klass, "_notify_origin", VALUEFUNC(_wrap_Resource__notify_origin), -1);
  rb_define_method(SwigClassResource.klass, "get_state_count", VALUEFUNC(_wrap_Resource_get_state_count), -1);
  rb_define_method(SwigClassResource.klass, "_dirty_state", VALUEFUNC(_wrap_Resource__dirty_state), -1);
  rb_define_method(SwigClassResource.klass, "_fire_loading_complete", VALUEFUNC(_wrap_Resource__fire_loading_complete), -1);
  rb_define_method(SwigClassResource.klass, "_fire_preparing_complete", VALUEFUNC(_wrap_Resource__fire_preparing_complete), -1);
  rb_define_method(SwigClassResource.klass, "_fire_unloading_complete", VALUEFUNC(_wrap_Resource__fire_unloading_complete), -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, "prepare_resource", VALUEFUNC(_wrap_ManualResourceLoader_prepare_resource), -1);
  rb_define_method(SwigClassManualResourceLoader.klass, "load_resource", VALUEFUNC(_wrap_ManualResourceLoader_load_resource), -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, "resource_group_scripting_started", VALUEFUNC(_wrap_ResourceGroupListener_resource_group_scripting_started), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "script_parse_started", VALUEFUNC(_wrap_ResourceGroupListener_script_parse_started), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "script_parse_ended", VALUEFUNC(_wrap_ResourceGroupListener_script_parse_ended), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resource_group_scripting_ended", VALUEFUNC(_wrap_ResourceGroupListener_resource_group_scripting_ended), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resource_group_prepare_started", VALUEFUNC(_wrap_ResourceGroupListener_resource_group_prepare_started), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resource_prepare_started", VALUEFUNC(_wrap_ResourceGroupListener_resource_prepare_started), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resource_prepare_ended", VALUEFUNC(_wrap_ResourceGroupListener_resource_prepare_ended), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "world_geometry_prepare_stage_started", VALUEFUNC(_wrap_ResourceGroupListener_world_geometry_prepare_stage_started), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "world_geometry_prepare_stage_ended", VALUEFUNC(_wrap_ResourceGroupListener_world_geometry_prepare_stage_ended), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resource_group_prepare_ended", VALUEFUNC(_wrap_ResourceGroupListener_resource_group_prepare_ended), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resource_group_load_started", VALUEFUNC(_wrap_ResourceGroupListener_resource_group_load_started), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resource_load_started", VALUEFUNC(_wrap_ResourceGroupListener_resource_load_started), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resource_load_ended", VALUEFUNC(_wrap_ResourceGroupListener_resource_load_ended), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "world_geometry_stage_started", VALUEFUNC(_wrap_ResourceGroupListener_world_geometry_stage_started), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "world_geometry_stage_ended", VALUEFUNC(_wrap_ResourceGroupListener_world_geometry_stage_ended), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resource_group_load_ended", VALUEFUNC(_wrap_ResourceGroupListener_resource_group_load_ended), -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, "resource_loading", VALUEFUNC(_wrap_ResourceLoadingListener_resource_loading), -1);
  rb_define_method(SwigClassResourceLoadingListener.klass, "resource_stream_opened", VALUEFUNC(_wrap_ResourceLoadingListener_resource_stream_opened), -1);
  rb_define_method(SwigClassResourceLoadingListener.klass, "resource_collision", VALUEFUNC(_wrap_ResourceLoadingListener_resource_collision), -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, "create_resource_group", VALUEFUNC(_wrap_ResourceGroupManager_create_resource_group), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "initialise_resource_group", VALUEFUNC(_wrap_ResourceGroupManager_initialise_resource_group), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "initialise_all_resource_groups", VALUEFUNC(_wrap_ResourceGroupManager_initialise_all_resource_groups), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "prepare_resource_group", VALUEFUNC(_wrap_ResourceGroupManager_prepare_resource_group), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "load_resource_group", VALUEFUNC(_wrap_ResourceGroupManager_load_resource_group), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "unload_resource_group", VALUEFUNC(_wrap_ResourceGroupManager_unload_resource_group), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "unload_unreferenced_resources_in_group", VALUEFUNC(_wrap_ResourceGroupManager_unload_unreferenced_resources_in_group), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "clear_resource_group", VALUEFUNC(_wrap_ResourceGroupManager_clear_resource_group), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "destroy_resource_group", VALUEFUNC(_wrap_ResourceGroupManager_destroy_resource_group), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "is_resource_group_initialised", VALUEFUNC(_wrap_ResourceGroupManager_is_resource_group_initialised), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "is_resource_group_loaded", VALUEFUNC(_wrap_ResourceGroupManager_is_resource_group_loaded), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "resource_group_exists", VALUEFUNC(_wrap_ResourceGroupManager_resource_group_exists), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "add_resource_location", VALUEFUNC(_wrap_ResourceGroupManager_add_resource_location), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "remove_resource_location", VALUEFUNC(_wrap_ResourceGroupManager_remove_resource_location), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "resource_location_exists", VALUEFUNC(_wrap_ResourceGroupManager_resource_location_exists), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "declare_resource", VALUEFUNC(_wrap_ResourceGroupManager_declare_resource), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "undeclare_resource", VALUEFUNC(_wrap_ResourceGroupManager_undeclare_resource), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "open_resource", VALUEFUNC(_wrap_ResourceGroupManager_open_resource), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "open_resources", VALUEFUNC(_wrap_ResourceGroupManager_open_resources), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "list_resource_names", VALUEFUNC(_wrap_ResourceGroupManager_list_resource_names), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "list_resource_file_info", VALUEFUNC(_wrap_ResourceGroupManager_list_resource_file_info), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "find_resource_names", VALUEFUNC(_wrap_ResourceGroupManager_find_resource_names), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "resource_exists_in_any_group", VALUEFUNC(_wrap_ResourceGroupManager_resource_exists_in_any_group), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "find_group_containing_resource", VALUEFUNC(_wrap_ResourceGroupManager_find_group_containing_resource), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "find_resource_file_info", VALUEFUNC(_wrap_ResourceGroupManager_find_resource_file_info), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "list_resource_locations", VALUEFUNC(_wrap_ResourceGroupManager_list_resource_locations), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "find_resource_location", VALUEFUNC(_wrap_ResourceGroupManager_find_resource_location), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "create_resource", VALUEFUNC(_wrap_ResourceGroupManager_create_resource), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "delete_resource", VALUEFUNC(_wrap_ResourceGroupManager_delete_resource), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "delete_matching_resources", VALUEFUNC(_wrap_ResourceGroupManager_delete_matching_resources), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "add_resource_group_listener", VALUEFUNC(_wrap_ResourceGroupManager_add_resource_group_listener), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "remove_resource_group_listener", VALUEFUNC(_wrap_ResourceGroupManager_remove_resource_group_listener), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "set_world_resource_group_name", VALUEFUNC(_wrap_ResourceGroupManager_set_world_resource_group_name), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "get_world_resource_group_name", VALUEFUNC(_wrap_ResourceGroupManager_get_world_resource_group_name), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "link_world_geometry_to_resource_group", VALUEFUNC(_wrap_ResourceGroupManager_link_world_geometry_to_resource_group), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "unlink_world_geometry_from_resource_group", VALUEFUNC(_wrap_ResourceGroupManager_unlink_world_geometry_from_resource_group), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "is_resource_group_in_global_pool", VALUEFUNC(_wrap_ResourceGroupManager_is_resource_group_in_global_pool), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "shutdown_all", VALUEFUNC(_wrap_ResourceGroupManager_shutdown_all), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_register_resource_manager", VALUEFUNC(_wrap_ResourceGroupManager__register_resource_manager), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_unregister_resource_manager", VALUEFUNC(_wrap_ResourceGroupManager__unregister_resource_manager), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "get_resource_manager_iterator", VALUEFUNC(_wrap_ResourceGroupManager_get_resource_manager_iterator), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_register_script_loader", VALUEFUNC(_wrap_ResourceGroupManager__register_script_loader), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_unregister_script_loader", VALUEFUNC(_wrap_ResourceGroupManager__unregister_script_loader), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_find_script_loader", VALUEFUNC(_wrap_ResourceGroupManager__find_script_loader), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_get_resource_manager", VALUEFUNC(_wrap_ResourceGroupManager__get_resource_manager), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_notify_resource_created", VALUEFUNC(_wrap_ResourceGroupManager__notify_resource_created), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_notify_resource_removed", VALUEFUNC(_wrap_ResourceGroupManager__notify_resource_removed), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_notify_resource_group_changed", VALUEFUNC(_wrap_ResourceGroupManager__notify_resource_group_changed), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_notify_all_resources_removed", VALUEFUNC(_wrap_ResourceGroupManager__notify_all_resources_removed), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_notify_world_geometry_stage_started", VALUEFUNC(_wrap_ResourceGroupManager__notify_world_geometry_stage_started), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_notify_world_geometry_stage_ended", VALUEFUNC(_wrap_ResourceGroupManager__notify_world_geometry_stage_ended), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "get_resource_groups", VALUEFUNC(_wrap_ResourceGroupManager_get_resource_groups), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "get_resource_declaration_list", VALUEFUNC(_wrap_ResourceGroupManager_get_resource_declaration_list), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "get_resource_location_list", VALUEFUNC(_wrap_ResourceGroupManager_get_resource_location_list), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "set_loading_listener", VALUEFUNC(_wrap_ResourceGroupManager_set_loading_listener), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "get_loading_listener", VALUEFUNC(_wrap_ResourceGroupManager_get_loading_listener), -1);
  rb_define_singleton_method(SwigClassResourceGroupManager.klass, "get_singleton", VALUEFUNC(_wrap_ResourceGroupManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassResourceGroupManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_ResourceGroupManager_get_singleton_ptr), -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, "get_script_patterns", VALUEFUNC(_wrap_ScriptLoader_get_script_patterns), -1);
  rb_define_method(SwigClassScriptLoader.klass, "parse_script", VALUEFUNC(_wrap_ScriptLoader_parse_script), -1);
  rb_define_method(SwigClassScriptLoader.klass, "get_loading_order", VALUEFUNC(_wrap_ScriptLoader_get_loading_order), -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, "get_name", VALUEFUNC(_wrap_ResourcePool_get_name), -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, "create_or_retrieve", VALUEFUNC(_wrap_ResourceManager_create_or_retrieve), -1);
  rb_define_method(SwigClassResourceManager.klass, "set_memory_budget", VALUEFUNC(_wrap_ResourceManager_set_memory_budget), -1);
  rb_define_method(SwigClassResourceManager.klass, "get_memory_budget", VALUEFUNC(_wrap_ResourceManager_get_memory_budget), -1);
  rb_define_method(SwigClassResourceManager.klass, "get_memory_usage", VALUEFUNC(_wrap_ResourceManager_get_memory_usage), -1);
  rb_define_method(SwigClassResourceManager.klass, "unload", VALUEFUNC(_wrap_ResourceManager_unload), -1);
  rb_define_method(SwigClassResourceManager.klass, "unload_all", VALUEFUNC(_wrap_ResourceManager_unload_all), -1);
  rb_define_method(SwigClassResourceManager.klass, "reload_all", VALUEFUNC(_wrap_ResourceManager_reload_all), -1);
  rb_define_method(SwigClassResourceManager.klass, "unload_unreferenced_resources", VALUEFUNC(_wrap_ResourceManager_unload_unreferenced_resources), -1);
  rb_define_method(SwigClassResourceManager.klass, "reload_unreferenced_resources", VALUEFUNC(_wrap_ResourceManager_reload_unreferenced_resources), -1);
  rb_define_method(SwigClassResourceManager.klass, "remove", VALUEFUNC(_wrap_ResourceManager_remove), -1);
  rb_define_method(SwigClassResourceManager.klass, "remove_all", VALUEFUNC(_wrap_ResourceManager_remove_all), -1);
  rb_define_method(SwigClassResourceManager.klass, "remove_unreferenced_resources", VALUEFUNC(_wrap_ResourceManager_remove_unreferenced_resources), -1);
  rb_define_method(SwigClassResourceManager.klass, "get_by_name", VALUEFUNC(_wrap_ResourceManager_get_by_name), -1);
  rb_define_method(SwigClassResourceManager.klass, "get_by_handle", VALUEFUNC(_wrap_ResourceManager_get_by_handle), -1);
  rb_define_method(SwigClassResourceManager.klass, "resource_exists", VALUEFUNC(_wrap_ResourceManager_resource_exists), -1);
  rb_define_method(SwigClassResourceManager.klass, "_notify_resource_touched", VALUEFUNC(_wrap_ResourceManager__notify_resource_touched), -1);
  rb_define_method(SwigClassResourceManager.klass, "_notify_resource_loaded", VALUEFUNC(_wrap_ResourceManager__notify_resource_loaded), -1);
  rb_define_method(SwigClassResourceManager.klass, "_notify_resource_unloaded", VALUEFUNC(_wrap_ResourceManager__notify_resource_unloaded), -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, "get_script_patterns", VALUEFUNC(_wrap_ResourceManager_get_script_patterns), -1);
  rb_define_method(SwigClassResourceManager.klass, "parse_script", VALUEFUNC(_wrap_ResourceManager_parse_script), -1);
  rb_define_method(SwigClassResourceManager.klass, "get_loading_order", VALUEFUNC(_wrap_ResourceManager_get_loading_order), -1);
  rb_define_method(SwigClassResourceManager.klass, "get_resource_type", VALUEFUNC(_wrap_ResourceManager_get_resource_type), -1);
  rb_define_method(SwigClassResourceManager.klass, "set_verbose", VALUEFUNC(_wrap_ResourceManager_set_verbose), -1);
  rb_define_method(SwigClassResourceManager.klass, "get_verbose", VALUEFUNC(_wrap_ResourceManager_get_verbose), -1);
  rb_define_method(SwigClassResourceManager.klass, "get_resource_pool", VALUEFUNC(_wrap_ResourceManager_get_resource_pool), -1);
  rb_define_method(SwigClassResourceManager.klass, "destroy_resource_pool", VALUEFUNC(_wrap_ResourceManager_destroy_resource_pool), -1);
  rb_define_method(SwigClassResourceManager.klass, "destroy_all_resource_pools", VALUEFUNC(_wrap_ResourceManager_destroy_all_resource_pools), -1);
  rb_define_method(SwigClassResourceManager.klass, "get_resource_iterator", VALUEFUNC(_wrap_ResourceManager_get_resource_iterator), -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, "get_archive_iterator", VALUEFUNC(_wrap_ArchiveManager_get_archive_iterator), -1);
  rb_define_method(SwigClassArchiveManager.klass, "add_archive_factory", VALUEFUNC(_wrap_ArchiveManager_add_archive_factory), -1);
  rb_define_singleton_method(SwigClassArchiveManager.klass, "get_singleton", VALUEFUNC(_wrap_ArchiveManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassArchiveManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_ArchiveManager_get_singleton_ptr), -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, "get_queue_group", VALUEFUNC(_wrap_RenderQueue_get_queue_group), -1);
  rb_define_method(SwigClassRenderQueue.klass, "add_renderable", VALUEFUNC(_wrap_RenderQueue_add_renderable), -1);
  rb_define_method(SwigClassRenderQueue.klass, "get_default_queue_group", VALUEFUNC(_wrap_RenderQueue_get_default_queue_group), -1);
  rb_define_method(SwigClassRenderQueue.klass, "set_default_renderable_priority", VALUEFUNC(_wrap_RenderQueue_set_default_renderable_priority), -1);
  rb_define_method(SwigClassRenderQueue.klass, "get_default_renderable_priority", VALUEFUNC(_wrap_RenderQueue_get_default_renderable_priority), -1);
  rb_define_method(SwigClassRenderQueue.klass, "set_default_queue_group", VALUEFUNC(_wrap_RenderQueue_set_default_queue_group), -1);
  rb_define_method(SwigClassRenderQueue.klass, "_get_queue_group_iterator", VALUEFUNC(_wrap_RenderQueue__get_queue_group_iterator), -1);
  rb_define_method(SwigClassRenderQueue.klass, "set_split_passes_by_lighting_type", VALUEFUNC(_wrap_RenderQueue_set_split_passes_by_lighting_type), -1);
  rb_define_method(SwigClassRenderQueue.klass, "get_split_passes_by_lighting_type", VALUEFUNC(_wrap_RenderQueue_get_split_passes_by_lighting_type), -1);
  rb_define_method(SwigClassRenderQueue.klass, "set_split_no_shadow_passes", VALUEFUNC(_wrap_RenderQueue_set_split_no_shadow_passes), -1);
  rb_define_method(SwigClassRenderQueue.klass, "get_split_no_shadow_passes", VALUEFUNC(_wrap_RenderQueue_get_split_no_shadow_passes), -1);
  rb_define_method(SwigClassRenderQueue.klass, "set_shadow_casters_cannot_be_receivers", VALUEFUNC(_wrap_RenderQueue_set_shadow_casters_cannot_be_receivers), -1);
  rb_define_method(SwigClassRenderQueue.klass, "get_shadow_casters_cannot_be_receivers", VALUEFUNC(_wrap_RenderQueue_get_shadow_casters_cannot_be_receivers), -1);
  rb_define_method(SwigClassRenderQueue.klass, "set_renderable_listener", VALUEFUNC(_wrap_RenderQueue_set_renderable_listener), -1);
  rb_define_method(SwigClassRenderQueue.klass, "get_renderable_listener", VALUEFUNC(_wrap_RenderQueue_get_renderable_listener), -1);
  rb_define_method(SwigClassRenderQueue.klass, "merge", VALUEFUNC(_wrap_RenderQueue_merge), -1);
  rb_define_method(SwigClassRenderQueue.klass, "process_visible_object", VALUEFUNC(_wrap_RenderQueue_process_visible_object), -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, "get_minimum", VALUEFUNC(_wrap_AxisAlignedBox_get_minimum), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "get_maximum", VALUEFUNC(_wrap_AxisAlignedBox_get_maximum), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "set_minimum", VALUEFUNC(_wrap_AxisAlignedBox_set_minimum), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "set_minimum_x", VALUEFUNC(_wrap_AxisAlignedBox_set_minimum_x), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "set_minimum_y", VALUEFUNC(_wrap_AxisAlignedBox_set_minimum_y), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "set_minimum_z", VALUEFUNC(_wrap_AxisAlignedBox_set_minimum_z), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "set_maximum", VALUEFUNC(_wrap_AxisAlignedBox_set_maximum), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "set_maximum_x", VALUEFUNC(_wrap_AxisAlignedBox_set_maximum_x), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "set_maximum_y", VALUEFUNC(_wrap_AxisAlignedBox_set_maximum_y), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "set_maximum_z", VALUEFUNC(_wrap_AxisAlignedBox_set_maximum_z), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "set_extents", VALUEFUNC(_wrap_AxisAlignedBox_set_extents), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "get_all_corners", VALUEFUNC(_wrap_AxisAlignedBox_get_all_corners), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "get_corner", VALUEFUNC(_wrap_AxisAlignedBox_get_corner), -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, "transform_affine", VALUEFUNC(_wrap_AxisAlignedBox_transform_affine), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "set_null", VALUEFUNC(_wrap_AxisAlignedBox_set_null), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "is_null", VALUEFUNC(_wrap_AxisAlignedBox_is_null), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "is_finite", VALUEFUNC(_wrap_AxisAlignedBox_is_finite), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "set_infinite", VALUEFUNC(_wrap_AxisAlignedBox_set_infinite), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "is_infinite", VALUEFUNC(_wrap_AxisAlignedBox_is_infinite), -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, "get_center", VALUEFUNC(_wrap_AxisAlignedBox_get_center), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "get_size", VALUEFUNC(_wrap_AxisAlignedBox_get_size), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "get_half_size", VALUEFUNC(_wrap_AxisAlignedBox_get_half_size), -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, "get_radius", VALUEFUNC(_wrap_Sphere_get_radius), -1);
  rb_define_method(SwigClassSphere.klass, "set_radius", VALUEFUNC(_wrap_Sphere_set_radius), -1);
  rb_define_method(SwigClassSphere.klass, "get_center", VALUEFUNC(_wrap_Sphere_get_center), -1);
  rb_define_method(SwigClassSphere.klass, "set_center", VALUEFUNC(_wrap_Sphere_set_center), -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, "get_manager", VALUEFUNC(_wrap_HardwareIndexBuffer_get_manager), -1);
  rb_define_method(SwigClassHardwareIndexBuffer.klass, "get_type", VALUEFUNC(_wrap_HardwareIndexBuffer_get_type), -1);
  rb_define_method(SwigClassHardwareIndexBuffer.klass, "get_num_indexes", VALUEFUNC(_wrap_HardwareIndexBuffer_get_num_indexes), -1);
  rb_define_method(SwigClassHardwareIndexBuffer.klass, "get_index_size", VALUEFUNC(_wrap_HardwareIndexBuffer_get_index_size), -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, "prepare_for_shadow_volume", VALUEFUNC(_wrap_VertexData_prepare_for_shadow_volume), -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, "reorganise_buffers", VALUEFUNC(_wrap_VertexData_reorganise_buffers), -1);
  rb_define_method(SwigClassVertexData.klass, "close_gaps_in_bindings", VALUEFUNC(_wrap_VertexData_close_gaps_in_bindings), -1);
  rb_define_method(SwigClassVertexData.klass, "remove_unused_buffers", VALUEFUNC(_wrap_VertexData_remove_unused_buffers), -1);
  rb_define_method(SwigClassVertexData.klass, "convert_packed_colour", VALUEFUNC(_wrap_VertexData_convert_packed_colour), -1);
  rb_define_method(SwigClassVertexData.klass, "allocate_hardware_animation_elements", VALUEFUNC(_wrap_VertexData_allocate_hardware_animation_elements), -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, "optimise_vertex_cache_tri_list", VALUEFUNC(_wrap_IndexData_optimise_vertex_cache_tri_list), -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, "get_hits", VALUEFUNC(_wrap_VertexCacheProfiler_get_hits), -1);
  rb_define_method(SwigClassVertexCacheProfiler.klass, "get_misses", VALUEFUNC(_wrap_VertexCacheProfiler_get_misses), -1);
  rb_define_method(SwigClassVertexCacheProfiler.klass, "get_size", VALUEFUNC(_wrap_VertexCacheProfiler_get_size), -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, "use_count", VALUEFUNC(_wrap_MaterialSharedPtr_use_count), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "use_count_pointer", VALUEFUNC(_wrap_MaterialSharedPtr_use_count_pointer), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_pointer", VALUEFUNC(_wrap_MaterialSharedPtr_get_pointer), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "free_method", VALUEFUNC(_wrap_MaterialSharedPtr_free_method), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "is_null", VALUEFUNC(_wrap_MaterialSharedPtr_is_null), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_null", VALUEFUNC(_wrap_MaterialSharedPtr_set_null), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "is_transparent", VALUEFUNC(_wrap_MaterialSharedPtr_is_transparent), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_receive_shadows", VALUEFUNC(_wrap_MaterialSharedPtr_set_receive_shadows), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_receive_shadows", VALUEFUNC(_wrap_MaterialSharedPtr_get_receive_shadows), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_transparency_casts_shadows", VALUEFUNC(_wrap_MaterialSharedPtr_set_transparency_casts_shadows), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_transparency_casts_shadows", VALUEFUNC(_wrap_MaterialSharedPtr_get_transparency_casts_shadows), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "create_technique", VALUEFUNC(_wrap_MaterialSharedPtr_create_technique), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_technique", VALUEFUNC(_wrap_MaterialSharedPtr_get_technique), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_num_techniques", VALUEFUNC(_wrap_MaterialSharedPtr_get_num_techniques), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "remove_technique", VALUEFUNC(_wrap_MaterialSharedPtr_remove_technique), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "remove_all_techniques", VALUEFUNC(_wrap_MaterialSharedPtr_remove_all_techniques), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_technique_iterator", VALUEFUNC(_wrap_MaterialSharedPtr_get_technique_iterator), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_supported_technique_iterator", VALUEFUNC(_wrap_MaterialSharedPtr_get_supported_technique_iterator), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_supported_technique", VALUEFUNC(_wrap_MaterialSharedPtr_get_supported_technique), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_num_supported_techniques", VALUEFUNC(_wrap_MaterialSharedPtr_get_num_supported_techniques), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_unsupported_techniques_explanation", VALUEFUNC(_wrap_MaterialSharedPtr_get_unsupported_techniques_explanation), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_num_lod_levels", VALUEFUNC(_wrap_MaterialSharedPtr_get_num_lod_levels), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_best_technique", VALUEFUNC(_wrap_MaterialSharedPtr_get_best_technique), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "clone", VALUEFUNC(_wrap_MaterialSharedPtr_clone), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "copy_details_to", VALUEFUNC(_wrap_MaterialSharedPtr_copy_details_to), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "compile", VALUEFUNC(_wrap_MaterialSharedPtr_compile), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_point_size", VALUEFUNC(_wrap_MaterialSharedPtr_set_point_size), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_ambient", VALUEFUNC(_wrap_MaterialSharedPtr_set_ambient), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_diffuse", VALUEFUNC(_wrap_MaterialSharedPtr_set_diffuse), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_specular", VALUEFUNC(_wrap_MaterialSharedPtr_set_specular), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_shininess", VALUEFUNC(_wrap_MaterialSharedPtr_set_shininess), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_self_illumination", VALUEFUNC(_wrap_MaterialSharedPtr_set_self_illumination), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_depth_check_enabled", VALUEFUNC(_wrap_MaterialSharedPtr_set_depth_check_enabled), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_depth_write_enabled", VALUEFUNC(_wrap_MaterialSharedPtr_set_depth_write_enabled), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_depth_function", VALUEFUNC(_wrap_MaterialSharedPtr_set_depth_function), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_colour_write_enabled", VALUEFUNC(_wrap_MaterialSharedPtr_set_colour_write_enabled), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_culling_mode", VALUEFUNC(_wrap_MaterialSharedPtr_set_culling_mode), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_manual_culling_mode", VALUEFUNC(_wrap_MaterialSharedPtr_set_manual_culling_mode), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_lighting_enabled", VALUEFUNC(_wrap_MaterialSharedPtr_set_lighting_enabled), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_shading_mode", VALUEFUNC(_wrap_MaterialSharedPtr_set_shading_mode), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_fog", VALUEFUNC(_wrap_MaterialSharedPtr_set_fog), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_depth_bias", VALUEFUNC(_wrap_MaterialSharedPtr_set_depth_bias), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_texture_filtering", VALUEFUNC(_wrap_MaterialSharedPtr_set_texture_filtering), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_texture_anisotropy", VALUEFUNC(_wrap_MaterialSharedPtr_set_texture_anisotropy), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_scene_blending", VALUEFUNC(_wrap_MaterialSharedPtr_set_scene_blending), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_separate_scene_blending", VALUEFUNC(_wrap_MaterialSharedPtr_set_separate_scene_blending), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "_notify_needs_recompile", VALUEFUNC(_wrap_MaterialSharedPtr__notify_needs_recompile), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_lod_levels", VALUEFUNC(_wrap_MaterialSharedPtr_set_lod_levels), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_lod_value_iterator", VALUEFUNC(_wrap_MaterialSharedPtr_get_lod_value_iterator), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_user_lod_value_iterator", VALUEFUNC(_wrap_MaterialSharedPtr_get_user_lod_value_iterator), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_lod_index", VALUEFUNC(_wrap_MaterialSharedPtr_get_lod_index), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_lod_strategy", VALUEFUNC(_wrap_MaterialSharedPtr_get_lod_strategy), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_lod_strategy", VALUEFUNC(_wrap_MaterialSharedPtr_set_lod_strategy), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "touch", VALUEFUNC(_wrap_MaterialSharedPtr_touch), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "apply_texture_aliases", VALUEFUNC(_wrap_MaterialSharedPtr_apply_texture_aliases), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_compilation_required", VALUEFUNC(_wrap_MaterialSharedPtr_get_compilation_required), -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, "is_reloadable", VALUEFUNC(_wrap_MaterialSharedPtr_is_reloadable), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "is_manually_loaded", VALUEFUNC(_wrap_MaterialSharedPtr_is_manually_loaded), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "unload", VALUEFUNC(_wrap_MaterialSharedPtr_unload), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_size", VALUEFUNC(_wrap_MaterialSharedPtr_get_size), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_name", VALUEFUNC(_wrap_MaterialSharedPtr_get_name), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_handle", VALUEFUNC(_wrap_MaterialSharedPtr_get_handle), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "is_prepared", VALUEFUNC(_wrap_MaterialSharedPtr_is_prepared), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "is_loaded", VALUEFUNC(_wrap_MaterialSharedPtr_is_loaded), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "is_loading", VALUEFUNC(_wrap_MaterialSharedPtr_is_loading), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_loading_state", VALUEFUNC(_wrap_MaterialSharedPtr_get_loading_state), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "is_background_loaded", VALUEFUNC(_wrap_MaterialSharedPtr_is_background_loaded), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_background_loaded", VALUEFUNC(_wrap_MaterialSharedPtr_set_background_loaded), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "escalate_loading", VALUEFUNC(_wrap_MaterialSharedPtr_escalate_loading), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "add_listener", VALUEFUNC(_wrap_MaterialSharedPtr_add_listener), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "remove_listener", VALUEFUNC(_wrap_MaterialSharedPtr_remove_listener), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_group", VALUEFUNC(_wrap_MaterialSharedPtr_get_group), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "change_group_ownership", VALUEFUNC(_wrap_MaterialSharedPtr_change_group_ownership), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_creator", VALUEFUNC(_wrap_MaterialSharedPtr_get_creator), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_origin", VALUEFUNC(_wrap_MaterialSharedPtr_get_origin), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "_notify_origin", VALUEFUNC(_wrap_MaterialSharedPtr__notify_origin), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_state_count", VALUEFUNC(_wrap_MaterialSharedPtr_get_state_count), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "_dirty_state", VALUEFUNC(_wrap_MaterialSharedPtr__dirty_state), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "_fire_loading_complete", VALUEFUNC(_wrap_MaterialSharedPtr__fire_loading_complete), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "_fire_preparing_complete", VALUEFUNC(_wrap_MaterialSharedPtr__fire_preparing_complete), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "_fire_unloading_complete", VALUEFUNC(_wrap_MaterialSharedPtr__fire_unloading_complete), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_param_dictionary", VALUEFUNC(_wrap_MaterialSharedPtr_get_param_dictionary), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_parameters", VALUEFUNC(_wrap_MaterialSharedPtr_get_parameters), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_parameter", VALUEFUNC(_wrap_MaterialSharedPtr_set_parameter), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "set_parameter_list", VALUEFUNC(_wrap_MaterialSharedPtr_set_parameter_list), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get_parameter", VALUEFUNC(_wrap_MaterialSharedPtr_get_parameter), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "copy_parameters_to", VALUEFUNC(_wrap_MaterialSharedPtr_copy_parameters_to), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "cleanup_dictionary", VALUEFUNC(_wrap_MaterialSharedPtr_cleanup_dictionary), -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, "is_transparent", VALUEFUNC(_wrap_Material_is_transparent), -1);
  rb_define_method(SwigClassMaterial.klass, "set_receive_shadows", VALUEFUNC(_wrap_Material_set_receive_shadows), -1);
  rb_define_method(SwigClassMaterial.klass, "get_receive_shadows", VALUEFUNC(_wrap_Material_get_receive_shadows), -1);
  rb_define_method(SwigClassMaterial.klass, "set_transparency_casts_shadows", VALUEFUNC(_wrap_Material_set_transparency_casts_shadows), -1);
  rb_define_method(SwigClassMaterial.klass, "get_transparency_casts_shadows", VALUEFUNC(_wrap_Material_get_transparency_casts_shadows), -1);
  rb_define_method(SwigClassMaterial.klass, "create_technique", VALUEFUNC(_wrap_Material_create_technique), -1);
  rb_define_method(SwigClassMaterial.klass, "get_technique", VALUEFUNC(_wrap_Material_get_technique), -1);
  rb_define_method(SwigClassMaterial.klass, "get_num_techniques", VALUEFUNC(_wrap_Material_get_num_techniques), -1);
  rb_define_method(SwigClassMaterial.klass, "remove_technique", VALUEFUNC(_wrap_Material_remove_technique), -1);
  rb_define_method(SwigClassMaterial.klass, "remove_all_techniques", VALUEFUNC(_wrap_Material_remove_all_techniques), -1);
  rb_define_method(SwigClassMaterial.klass, "get_technique_iterator", VALUEFUNC(_wrap_Material_get_technique_iterator), -1);
  rb_define_method(SwigClassMaterial.klass, "get_supported_technique_iterator", VALUEFUNC(_wrap_Material_get_supported_technique_iterator), -1);
  rb_define_method(SwigClassMaterial.klass, "get_supported_technique", VALUEFUNC(_wrap_Material_get_supported_technique), -1);
  rb_define_method(SwigClassMaterial.klass, "get_num_supported_techniques", VALUEFUNC(_wrap_Material_get_num_supported_techniques), -1);
  rb_define_method(SwigClassMaterial.klass, "get_unsupported_techniques_explanation", VALUEFUNC(_wrap_Material_get_unsupported_techniques_explanation), -1);
  rb_define_method(SwigClassMaterial.klass, "get_num_lod_levels", VALUEFUNC(_wrap_Material_get_num_lod_levels), -1);
  rb_define_method(SwigClassMaterial.klass, "get_best_technique", VALUEFUNC(_wrap_Material_get_best_technique), -1);
  rb_define_method(SwigClassMaterial.klass, "clone", VALUEFUNC(_wrap_Material_clone), -1);
  rb_define_method(SwigClassMaterial.klass, "copy_details_to", VALUEFUNC(_wrap_Material_copy_details_to), -1);
  rb_define_method(SwigClassMaterial.klass, "compile", VALUEFUNC(_wrap_Material_compile), -1);
  rb_define_method(SwigClassMaterial.klass, "set_point_size", VALUEFUNC(_wrap_Material_set_point_size), -1);
  rb_define_method(SwigClassMaterial.klass, "set_ambient", VALUEFUNC(_wrap_Material_set_ambient), -1);
  rb_define_method(SwigClassMaterial.klass, "set_diffuse", VALUEFUNC(_wrap_Material_set_diffuse), -1);
  rb_define_method(SwigClassMaterial.klass, "set_specular", VALUEFUNC(_wrap_Material_set_specular), -1);
  rb_define_method(SwigClassMaterial.klass, "set_shininess", VALUEFUNC(_wrap_Material_set_shininess), -1);
  rb_define_method(SwigClassMaterial.klass, "set_self_illumination", VALUEFUNC(_wrap_Material_set_self_illumination), -1);
  rb_define_method(SwigClassMaterial.klass, "set_depth_check_enabled", VALUEFUNC(_wrap_Material_set_depth_check_enabled), -1);
  rb_define_method(SwigClassMaterial.klass, "set_depth_write_enabled", VALUEFUNC(_wrap_Material_set_depth_write_enabled), -1);
  rb_define_method(SwigClassMaterial.klass, "set_depth_function", VALUEFUNC(_wrap_Material_set_depth_function), -1);
  rb_define_method(SwigClassMaterial.klass, "set_colour_write_enabled", VALUEFUNC(_wrap_Material_set_colour_write_enabled), -1);
  rb_define_method(SwigClassMaterial.klass, "set_culling_mode", VALUEFUNC(_wrap_Material_set_culling_mode), -1);
  rb_define_method(SwigClassMaterial.klass, "set_manual_culling_mode", VALUEFUNC(_wrap_Material_set_manual_culling_mode), -1);
  rb_define_method(SwigClassMaterial.klass, "set_lighting_enabled", VALUEFUNC(_wrap_Material_set_lighting_enabled), -1);
  rb_define_method(SwigClassMaterial.klass, "set_shading_mode", VALUEFUNC(_wrap_Material_set_shading_mode), -1);
  rb_define_method(SwigClassMaterial.klass, "set_fog", VALUEFUNC(_wrap_Material_set_fog), -1);
  rb_define_method(SwigClassMaterial.klass, "set_depth_bias", VALUEFUNC(_wrap_Material_set_depth_bias), -1);
  rb_define_method(SwigClassMaterial.klass, "set_texture_filtering", VALUEFUNC(_wrap_Material_set_texture_filtering), -1);
  rb_define_method(SwigClassMaterial.klass, "set_texture_anisotropy", VALUEFUNC(_wrap_Material_set_texture_anisotropy), -1);
  rb_define_method(SwigClassMaterial.klass, "set_scene_blending", VALUEFUNC(_wrap_Material_set_scene_blending), -1);
  rb_define_method(SwigClassMaterial.klass, "set_separate_scene_blending", VALUEFUNC(_wrap_Material_set_separate_scene_blending), -1);
  rb_define_method(SwigClassMaterial.klass, "_notify_needs_recompile", VALUEFUNC(_wrap_Material__notify_needs_recompile), -1);
  rb_define_method(SwigClassMaterial.klass, "set_lod_levels", VALUEFUNC(_wrap_Material_set_lod_levels), -1);
  rb_define_method(SwigClassMaterial.klass, "get_lod_value_iterator", VALUEFUNC(_wrap_Material_get_lod_value_iterator), -1);
  rb_define_method(SwigClassMaterial.klass, "get_user_lod_value_iterator", VALUEFUNC(_wrap_Material_get_user_lod_value_iterator), -1);
  rb_define_method(SwigClassMaterial.klass, "get_lod_index", VALUEFUNC(_wrap_Material_get_lod_index), -1);
  rb_define_method(SwigClassMaterial.klass, "get_lod_strategy", VALUEFUNC(_wrap_Material_get_lod_strategy), -1);
  rb_define_method(SwigClassMaterial.klass, "set_lod_strategy", VALUEFUNC(_wrap_Material_set_lod_strategy), -1);
  rb_define_method(SwigClassMaterial.klass, "touch", VALUEFUNC(_wrap_Material_touch), -1);
  rb_define_method(SwigClassMaterial.klass, "apply_texture_aliases", VALUEFUNC(_wrap_Material_apply_texture_aliases), -1);
  rb_define_method(SwigClassMaterial.klass, "get_compilation_required", VALUEFUNC(_wrap_Material_get_compilation_required), -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, "is_float", VALUEFUNC(_wrap_GpuConstantDefinition_is_float), -1);
  rb_define_singleton_method(SwigClassGpuConstantDefinition.klass, "is_sampler", VALUEFUNC(_wrap_GpuConstantDefinition_is_sampler), -1);
  rb_define_singleton_method(SwigClassGpuConstantDefinition.klass, "get_element_size", VALUEFUNC(_wrap_GpuConstantDefinition_get_element_size), -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, "generate_constant_definition_array_entries", VALUEFUNC(_wrap_GpuNamedConstants_generate_constant_definition_array_entries), -1);
  rb_define_singleton_method(SwigClassGpuNamedConstants.klass, "get_generate_all_constant_definition_array_entries", VALUEFUNC(_wrap_GpuNamedConstants_get_generate_all_constant_definition_array_entries), -1);
  rb_define_singleton_method(SwigClassGpuNamedConstants.klass, "set_generate_all_constant_definition_array_entries", VALUEFUNC(_wrap_GpuNamedConstants_set_generate_all_constant_definition_array_entries), -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, "export_named_constants", VALUEFUNC(_wrap_GpuNamedConstantsSerializer_export_named_constants), -1);
  rb_define_method(SwigClassGpuNamedConstantsSerializer.klass, "import_named_constants", VALUEFUNC(_wrap_GpuNamedConstantsSerializer_import_named_constants), -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, "get_name", VALUEFUNC(_wrap_GpuSharedParameters_get_name), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "add_constant_definition", VALUEFUNC(_wrap_GpuSharedParameters_add_constant_definition), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "remove_constant_definition", VALUEFUNC(_wrap_GpuSharedParameters_remove_constant_definition), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "remove_all_constant_definitions", VALUEFUNC(_wrap_GpuSharedParameters_remove_all_constant_definitions), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "get_version", VALUEFUNC(_wrap_GpuSharedParameters_get_version), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "_mark_dirty", VALUEFUNC(_wrap_GpuSharedParameters__mark_dirty), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "get_frame_last_updated", VALUEFUNC(_wrap_GpuSharedParameters_get_frame_last_updated), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "get_constant_definition_iterator", VALUEFUNC(_wrap_GpuSharedParameters_get_constant_definition_iterator), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "get_constant_definition", VALUEFUNC(_wrap_GpuSharedParameters_get_constant_definition), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "get_constant_definitions", VALUEFUNC(_wrap_GpuSharedParameters_get_constant_definitions), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "set_named_constant", VALUEFUNC(_wrap_GpuSharedParameters_set_named_constant), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "get_float_pointer", VALUEFUNC(_wrap_GpuSharedParameters_get_float_pointer), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "get_int_pointer", VALUEFUNC(_wrap_GpuSharedParameters_get_int_pointer), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "_set_render_system_data", VALUEFUNC(_wrap_GpuSharedParameters__set_render_system_data), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "_get_render_system_data", VALUEFUNC(_wrap_GpuSharedParameters__get_render_system_data), -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, "_copy_shared_params_to_target_params", VALUEFUNC(_wrap_GpuSharedParametersUsage__copy_shared_params_to_target_params), -1);
  rb_define_method(SwigClassGpuSharedParametersUsage.klass, "get_name", VALUEFUNC(_wrap_GpuSharedParametersUsage_get_name), -1);
  rb_define_method(SwigClassGpuSharedParametersUsage.klass, "get_shared_params", VALUEFUNC(_wrap_GpuSharedParametersUsage_get_shared_params), -1);
  rb_define_method(SwigClassGpuSharedParametersUsage.klass, "get_target_params", VALUEFUNC(_wrap_GpuSharedParametersUsage_get_target_params), -1);
  rb_define_method(SwigClassGpuSharedParametersUsage.klass, "_set_render_system_data", VALUEFUNC(_wrap_GpuSharedParametersUsage__set_render_system_data), -1);
  rb_define_method(SwigClassGpuSharedParametersUsage.klass, "_get_render_system_data", VALUEFUNC(_wrap_GpuSharedParametersUsage__get_render_system_data), -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, "_set_named_constants", VALUEFUNC(_wrap_GpuProgramParameters__set_named_constants), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_set_logical_indexes", VALUEFUNC(_wrap_GpuProgramParameters__set_logical_indexes), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "has_named_parameters", VALUEFUNC(_wrap_GpuProgramParameters_has_named_parameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "has_logical_indexed_parameters", VALUEFUNC(_wrap_GpuProgramParameters_has_logical_indexed_parameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "set_constant", VALUEFUNC(_wrap_GpuProgramParameters_set_constant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_write_raw_constants", VALUEFUNC(_wrap_GpuProgramParameters__write_raw_constants), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_read_raw_constants", VALUEFUNC(_wrap_GpuProgramParameters__read_raw_constants), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_write_raw_constant", VALUEFUNC(_wrap_GpuProgramParameters__write_raw_constant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_constant_definition_iterator", VALUEFUNC(_wrap_GpuProgramParameters_get_constant_definition_iterator), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_constant_definition", VALUEFUNC(_wrap_GpuProgramParameters_get_constant_definition), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_constant_definitions", VALUEFUNC(_wrap_GpuProgramParameters_get_constant_definitions), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_float_logical_buffer_struct", VALUEFUNC(_wrap_GpuProgramParameters_get_float_logical_buffer_struct), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_float_logical_index_for_physical_index", VALUEFUNC(_wrap_GpuProgramParameters_get_float_logical_index_for_physical_index), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_int_logical_index_for_physical_index", VALUEFUNC(_wrap_GpuProgramParameters_get_int_logical_index_for_physical_index), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_int_logical_buffer_struct", VALUEFUNC(_wrap_GpuProgramParameters_get_int_logical_buffer_struct), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_float_constant_list", VALUEFUNC(_wrap_GpuProgramParameters_get_float_constant_list), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_float_pointer", VALUEFUNC(_wrap_GpuProgramParameters_get_float_pointer), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_int_constant_list", VALUEFUNC(_wrap_GpuProgramParameters_get_int_constant_list), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_int_pointer", VALUEFUNC(_wrap_GpuProgramParameters_get_int_pointer), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_auto_constant_list", VALUEFUNC(_wrap_GpuProgramParameters_get_auto_constant_list), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "set_auto_constant_real", VALUEFUNC(_wrap_GpuProgramParameters_set_auto_constant_real), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "set_auto_constant", VALUEFUNC(_wrap_GpuProgramParameters_set_auto_constant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_set_raw_auto_constant", VALUEFUNC(_wrap_GpuProgramParameters__set_raw_auto_constant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_set_raw_auto_constant_real", VALUEFUNC(_wrap_GpuProgramParameters__set_raw_auto_constant_real), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "clear_auto_constant", VALUEFUNC(_wrap_GpuProgramParameters_clear_auto_constant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "set_constant_from_time", VALUEFUNC(_wrap_GpuProgramParameters_set_constant_from_time), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "clear_auto_constants", VALUEFUNC(_wrap_GpuProgramParameters_clear_auto_constants), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_auto_constant_iterator", VALUEFUNC(_wrap_GpuProgramParameters_get_auto_constant_iterator), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_auto_constant_count", VALUEFUNC(_wrap_GpuProgramParameters_get_auto_constant_count), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_auto_constant_entry", VALUEFUNC(_wrap_GpuProgramParameters_get_auto_constant_entry), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "has_auto_constants", VALUEFUNC(_wrap_GpuProgramParameters_has_auto_constants), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "find_float_auto_constant_entry", VALUEFUNC(_wrap_GpuProgramParameters_find_float_auto_constant_entry), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "find_int_auto_constant_entry", VALUEFUNC(_wrap_GpuProgramParameters_find_int_auto_constant_entry), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "find_auto_constant_entry", VALUEFUNC(_wrap_GpuProgramParameters_find_auto_constant_entry), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_find_raw_auto_constant_entry_float", VALUEFUNC(_wrap_GpuProgramParameters__find_raw_auto_constant_entry_float), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_find_raw_auto_constant_entry_int", VALUEFUNC(_wrap_GpuProgramParameters__find_raw_auto_constant_entry_int), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_update_auto_params", VALUEFUNC(_wrap_GpuProgramParameters__update_auto_params), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "set_ignore_missing_params", VALUEFUNC(_wrap_GpuProgramParameters_set_ignore_missing_params), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "set_named_constant", VALUEFUNC(_wrap_GpuProgramParameters_set_named_constant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "set_named_auto_constant_real", VALUEFUNC(_wrap_GpuProgramParameters_set_named_auto_constant_real), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "set_named_auto_constant", VALUEFUNC(_wrap_GpuProgramParameters_set_named_auto_constant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "set_named_constant_from_time", VALUEFUNC(_wrap_GpuProgramParameters_set_named_constant_from_time), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "clear_named_auto_constant", VALUEFUNC(_wrap_GpuProgramParameters_clear_named_auto_constant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_find_named_constant_definition", VALUEFUNC(_wrap_GpuProgramParameters__find_named_constant_definition), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_get_float_constant_physical_index", VALUEFUNC(_wrap_GpuProgramParameters__get_float_constant_physical_index), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_get_int_constant_physical_index", VALUEFUNC(_wrap_GpuProgramParameters__get_int_constant_physical_index), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "set_transpose_matrices", VALUEFUNC(_wrap_GpuProgramParameters_set_transpose_matrices), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_transpose_matrices", VALUEFUNC(_wrap_GpuProgramParameters_get_transpose_matrices), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "copy_constants_from", VALUEFUNC(_wrap_GpuProgramParameters_copy_constants_from), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "copy_matching_named_constants_from", VALUEFUNC(_wrap_GpuProgramParameters_copy_matching_named_constants_from), -1);
  rb_define_singleton_method(SwigClassGpuProgramParameters.klass, "get_auto_constant_definition", VALUEFUNC(_wrap_GpuProgramParameters_get_auto_constant_definition), -1);
  rb_define_singleton_method(SwigClassGpuProgramParameters.klass, "get_num_auto_constant_definitions", VALUEFUNC(_wrap_GpuProgramParameters_get_num_auto_constant_definitions), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "inc_pass_iteration_number", VALUEFUNC(_wrap_GpuProgramParameters_inc_pass_iteration_number), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "has_pass_iteration_number", VALUEFUNC(_wrap_GpuProgramParameters_has_pass_iteration_number), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_pass_iteration_number_index", VALUEFUNC(_wrap_GpuProgramParameters_get_pass_iteration_number_index), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "add_shared_parameters", VALUEFUNC(_wrap_GpuProgramParameters_add_shared_parameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "is_using_shared_parameters", VALUEFUNC(_wrap_GpuProgramParameters_is_using_shared_parameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "remove_shared_parameters", VALUEFUNC(_wrap_GpuProgramParameters_remove_shared_parameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "remove_all_shared_parameters", VALUEFUNC(_wrap_GpuProgramParameters_remove_all_shared_parameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "get_shared_parameters", VALUEFUNC(_wrap_GpuProgramParameters_get_shared_parameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_set_render_system_data", VALUEFUNC(_wrap_GpuProgramParameters__set_render_system_data), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_get_render_system_data", VALUEFUNC(_wrap_GpuProgramParameters__get_render_system_data), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_copy_shared_params", VALUEFUNC(_wrap_GpuProgramParameters__copy_shared_params), -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, "set_source_file", VALUEFUNC(_wrap_GpuProgram_set_source_file), -1);
  rb_define_method(SwigClassGpuProgram.klass, "set_source", VALUEFUNC(_wrap_GpuProgram_set_source), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_syntax_code", VALUEFUNC(_wrap_GpuProgram_get_syntax_code), -1);
  rb_define_method(SwigClassGpuProgram.klass, "set_syntax_code", VALUEFUNC(_wrap_GpuProgram_set_syntax_code), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_source_file", VALUEFUNC(_wrap_GpuProgram_get_source_file), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_source", VALUEFUNC(_wrap_GpuProgram_get_source), -1);
  rb_define_method(SwigClassGpuProgram.klass, "set_type", VALUEFUNC(_wrap_GpuProgram_set_type), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_type", VALUEFUNC(_wrap_GpuProgram_get_type), -1);
  rb_define_method(SwigClassGpuProgram.klass, "_get_binding_delegate", VALUEFUNC(_wrap_GpuProgram__get_binding_delegate), -1);
  rb_define_method(SwigClassGpuProgram.klass, "is_supported", VALUEFUNC(_wrap_GpuProgram_is_supported), -1);
  rb_define_method(SwigClassGpuProgram.klass, "create_parameters", VALUEFUNC(_wrap_GpuProgram_create_parameters), -1);
  rb_define_method(SwigClassGpuProgram.klass, "set_skeletal_animation_included", VALUEFUNC(_wrap_GpuProgram_set_skeletal_animation_included), -1);
  rb_define_method(SwigClassGpuProgram.klass, "is_skeletal_animation_included", VALUEFUNC(_wrap_GpuProgram_is_skeletal_animation_included), -1);
  rb_define_method(SwigClassGpuProgram.klass, "set_morph_animation_included", VALUEFUNC(_wrap_GpuProgram_set_morph_animation_included), -1);
  rb_define_method(SwigClassGpuProgram.klass, "set_pose_animation_included", VALUEFUNC(_wrap_GpuProgram_set_pose_animation_included), -1);
  rb_define_method(SwigClassGpuProgram.klass, "is_morph_animation_included", VALUEFUNC(_wrap_GpuProgram_is_morph_animation_included), -1);
  rb_define_method(SwigClassGpuProgram.klass, "is_pose_animation_included", VALUEFUNC(_wrap_GpuProgram_is_pose_animation_included), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_number_of_poses_included", VALUEFUNC(_wrap_GpuProgram_get_number_of_poses_included), -1);
  rb_define_method(SwigClassGpuProgram.klass, "set_vertex_texture_fetch_required", VALUEFUNC(_wrap_GpuProgram_set_vertex_texture_fetch_required), -1);
  rb_define_method(SwigClassGpuProgram.klass, "is_vertex_texture_fetch_required", VALUEFUNC(_wrap_GpuProgram_is_vertex_texture_fetch_required), -1);
  rb_define_method(SwigClassGpuProgram.klass, "set_adjacency_info_required", VALUEFUNC(_wrap_GpuProgram_set_adjacency_info_required), -1);
  rb_define_method(SwigClassGpuProgram.klass, "is_adjacency_info_required", VALUEFUNC(_wrap_GpuProgram_is_adjacency_info_required), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_default_parameters", VALUEFUNC(_wrap_GpuProgram_get_default_parameters), -1);
  rb_define_method(SwigClassGpuProgram.klass, "has_default_parameters", VALUEFUNC(_wrap_GpuProgram_has_default_parameters), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_pass_surface_and_light_states", VALUEFUNC(_wrap_GpuProgram_get_pass_surface_and_light_states), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_pass_fog_states", VALUEFUNC(_wrap_GpuProgram_get_pass_fog_states), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_pass_transform_states", VALUEFUNC(_wrap_GpuProgram_get_pass_transform_states), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_language", VALUEFUNC(_wrap_GpuProgram_get_language), -1);
  rb_define_method(SwigClassGpuProgram.klass, "has_compile_error", VALUEFUNC(_wrap_GpuProgram_has_compile_error), -1);
  rb_define_method(SwigClassGpuProgram.klass, "reset_compile_error", VALUEFUNC(_wrap_GpuProgram_reset_compile_error), -1);
  rb_define_method(SwigClassGpuProgram.klass, "set_manual_named_constants", VALUEFUNC(_wrap_GpuProgram_set_manual_named_constants), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_named_constants", VALUEFUNC(_wrap_GpuProgram_get_named_constants), -1);
  rb_define_method(SwigClassGpuProgram.klass, "set_manual_named_constants_file", VALUEFUNC(_wrap_GpuProgram_set_manual_named_constants_file), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_manual_named_constants_file", VALUEFUNC(_wrap_GpuProgram_get_manual_named_constants_file), -1);
  rb_define_method(SwigClassGpuProgram.klass, "get_constant_definitions", VALUEFUNC(_wrap_GpuProgram_get_constant_definitions), -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, "set_user_any", VALUEFUNC(_wrap_UserObjectBindings_set_user_any), -1);
  rb_define_method(SwigClassUserObjectBindings.klass, "get_user_any", VALUEFUNC(_wrap_UserObjectBindings_get_user_any), -1);
  rb_define_method(SwigClassUserObjectBindings.klass, "erase_user_any", VALUEFUNC(_wrap_UserObjectBindings_erase_user_any), -1);
  rb_define_method(SwigClassUserObjectBindings.klass, "clear", VALUEFUNC(_wrap_UserObjectBindings_clear), -1);
  rb_define_singleton_method(SwigClassUserObjectBindings.klass, "get_empty_user_any", VALUEFUNC(_wrap_UserObjectBindings_get_empty_user_any), -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, "get_material", VALUEFUNC(_wrap_Renderable_get_material), -1);
  rb_define_method(SwigClassRenderable.klass, "get_technique", VALUEFUNC(_wrap_Renderable_get_technique), -1);
  rb_define_method(SwigClassRenderable.klass, "get_render_operation", VALUEFUNC(_wrap_Renderable_get_render_operation), -1);
  rb_define_method(SwigClassRenderable.klass, "pre_render", VALUEFUNC(_wrap_Renderable_pre_render), -1);
  rb_define_method(SwigClassRenderable.klass, "post_render", VALUEFUNC(_wrap_Renderable_post_render), -1);
  rb_define_method(SwigClassRenderable.klass, "get_world_transforms", VALUEFUNC(_wrap_Renderable_get_world_transforms), -1);
  rb_define_method(SwigClassRenderable.klass, "get_num_world_transforms", VALUEFUNC(_wrap_Renderable_get_num_world_transforms), -1);
  rb_define_method(SwigClassRenderable.klass, "set_use_identity_projection", VALUEFUNC(_wrap_Renderable_set_use_identity_projection), -1);
  rb_define_method(SwigClassRenderable.klass, "get_use_identity_projection", VALUEFUNC(_wrap_Renderable_get_use_identity_projection), -1);
  rb_define_method(SwigClassRenderable.klass, "set_use_identity_view", VALUEFUNC(_wrap_Renderable_set_use_identity_view), -1);
  rb_define_method(SwigClassRenderable.klass, "get_use_identity_view", VALUEFUNC(_wrap_Renderable_get_use_identity_view), -1);
  rb_define_method(SwigClassRenderable.klass, "get_squared_view_depth", VALUEFUNC(_wrap_Renderable_get_squared_view_depth), -1);
  rb_define_method(SwigClassRenderable.klass, "get_lights", VALUEFUNC(_wrap_Renderable_get_lights), -1);
  rb_define_method(SwigClassRenderable.klass, "get_casts_shadows", VALUEFUNC(_wrap_Renderable_get_casts_shadows), -1);
  rb_define_method(SwigClassRenderable.klass, "set_custom_parameter", VALUEFUNC(_wrap_Renderable_set_custom_parameter), -1);
  rb_define_method(SwigClassRenderable.klass, "remove_custom_parameter", VALUEFUNC(_wrap_Renderable_remove_custom_parameter), -1);
  rb_define_method(SwigClassRenderable.klass, "has_custom_parameter", VALUEFUNC(_wrap_Renderable_has_custom_parameter), -1);
  rb_define_method(SwigClassRenderable.klass, "get_custom_parameter", VALUEFUNC(_wrap_Renderable_get_custom_parameter), -1);
  rb_define_method(SwigClassRenderable.klass, "_update_custom_gpu_parameter", VALUEFUNC(_wrap_Renderable__update_custom_gpu_parameter), -1);
  rb_define_method(SwigClassRenderable.klass, "set_polygon_mode_overrideable", VALUEFUNC(_wrap_Renderable_set_polygon_mode_overrideable), -1);
  rb_define_method(SwigClassRenderable.klass, "get_polygon_mode_overrideable", VALUEFUNC(_wrap_Renderable_get_polygon_mode_overrideable), -1);
  rb_define_method(SwigClassRenderable.klass, "set_user_any", VALUEFUNC(_wrap_Renderable_set_user_any), -1);
  rb_define_method(SwigClassRenderable.klass, "get_user_any", VALUEFUNC(_wrap_Renderable_get_user_any), -1);
  rb_define_method(SwigClassRenderable.klass, "get_user_object_bindings", VALUEFUNC(_wrap_Renderable_get_user_object_bindings), -1);
  rb_define_method(SwigClassRenderable.klass, "get_render_system_data", VALUEFUNC(_wrap_Renderable_get_render_system_data), -1);
  rb_define_method(SwigClassRenderable.klass, "set_render_system_data", VALUEFUNC(_wrap_Renderable_set_render_system_data), -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, "set_material", VALUEFUNC(_wrap_ShadowRenderable_set_material), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "get_material", VALUEFUNC(_wrap_ShadowRenderable_get_material), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "get_render_operation", VALUEFUNC(_wrap_ShadowRenderable_get_render_operation), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "get_render_operation_for_update", VALUEFUNC(_wrap_ShadowRenderable_get_render_operation_for_update), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "get_world_transforms", VALUEFUNC(_wrap_ShadowRenderable_get_world_transforms), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "get_squared_view_depth", VALUEFUNC(_wrap_ShadowRenderable_get_squared_view_depth), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "get_lights", VALUEFUNC(_wrap_ShadowRenderable_get_lights), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "is_light_cap_separate", VALUEFUNC(_wrap_ShadowRenderable_is_light_cap_separate), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "get_light_cap_renderable", VALUEFUNC(_wrap_ShadowRenderable_get_light_cap_renderable), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "is_visible", VALUEFUNC(_wrap_ShadowRenderable_is_visible), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "rebind_index_buffer", VALUEFUNC(_wrap_ShadowRenderable_rebind_index_buffer), -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, "get_cast_shadows", VALUEFUNC(_wrap_ShadowCaster_get_cast_shadows), -1);
  rb_define_method(SwigClassShadowCaster.klass, "get_edge_list", VALUEFUNC(_wrap_ShadowCaster_get_edge_list), -1);
  rb_define_method(SwigClassShadowCaster.klass, "has_edge_list", VALUEFUNC(_wrap_ShadowCaster_has_edge_list), -1);
  rb_define_method(SwigClassShadowCaster.klass, "get_world_bounding_box", VALUEFUNC(_wrap_ShadowCaster_get_world_bounding_box), -1);
  rb_define_method(SwigClassShadowCaster.klass, "get_light_cap_bounds", VALUEFUNC(_wrap_ShadowCaster_get_light_cap_bounds), -1);
  rb_define_method(SwigClassShadowCaster.klass, "get_dark_cap_bounds", VALUEFUNC(_wrap_ShadowCaster_get_dark_cap_bounds), -1);
  rb_define_method(SwigClassShadowCaster.klass, "get_shadow_volume_renderable_iterator", VALUEFUNC(_wrap_ShadowCaster_get_shadow_volume_renderable_iterator), -1);
  rb_define_singleton_method(SwigClassShadowCaster.klass, "extrude_vertices", VALUEFUNC(_wrap_ShadowCaster_extrude_vertices), -1);
  rb_define_method(SwigClassShadowCaster.klass, "get_point_extrusion_distance", VALUEFUNC(_wrap_ShadowCaster_get_point_extrusion_distance), -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, "_notify_creator", VALUEFUNC(_wrap_MovableObject__notify_creator), -1);
  rb_define_method(SwigClassMovableObject.klass, "_get_creator", VALUEFUNC(_wrap_MovableObject__get_creator), -1);
  rb_define_method(SwigClassMovableObject.klass, "_notify_manager", VALUEFUNC(_wrap_MovableObject__notify_manager), -1);
  rb_define_method(SwigClassMovableObject.klass, "_get_manager", VALUEFUNC(_wrap_MovableObject__get_manager), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_name", VALUEFUNC(_wrap_MovableObject_get_name), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_movable_type", VALUEFUNC(_wrap_MovableObject_get_movable_type), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_parent_node", VALUEFUNC(_wrap_MovableObject_get_parent_node), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_parent_scene_node", VALUEFUNC(_wrap_MovableObject_get_parent_scene_node), -1);
  rb_define_method(SwigClassMovableObject.klass, "is_parent_tag_point", VALUEFUNC(_wrap_MovableObject_is_parent_tag_point), -1);
  rb_define_method(SwigClassMovableObject.klass, "_notify_attached", VALUEFUNC(_wrap_MovableObject__notify_attached), -1);
  rb_define_method(SwigClassMovableObject.klass, "is_attached", VALUEFUNC(_wrap_MovableObject_is_attached), -1);
  rb_define_method(SwigClassMovableObject.klass, "detach_from_parent", VALUEFUNC(_wrap_MovableObject_detach_from_parent), -1);
  rb_define_method(SwigClassMovableObject.klass, "is_in_scene", VALUEFUNC(_wrap_MovableObject_is_in_scene), -1);
  rb_define_method(SwigClassMovableObject.klass, "_notify_moved", VALUEFUNC(_wrap_MovableObject__notify_moved), -1);
  rb_define_method(SwigClassMovableObject.klass, "_notify_current_camera", VALUEFUNC(_wrap_MovableObject__notify_current_camera), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_bounding_box", VALUEFUNC(_wrap_MovableObject_get_bounding_box), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_bounding_radius", VALUEFUNC(_wrap_MovableObject_get_bounding_radius), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_world_bounding_box", VALUEFUNC(_wrap_MovableObject_get_world_bounding_box), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_world_bounding_sphere", VALUEFUNC(_wrap_MovableObject_get_world_bounding_sphere), -1);
  rb_define_method(SwigClassMovableObject.klass, "_update_render_queue", VALUEFUNC(_wrap_MovableObject__update_render_queue), -1);
  rb_define_method(SwigClassMovableObject.klass, "set_visible", VALUEFUNC(_wrap_MovableObject_set_visible), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_visible", VALUEFUNC(_wrap_MovableObject_get_visible), -1);
  rb_define_method(SwigClassMovableObject.klass, "is_visible", VALUEFUNC(_wrap_MovableObject_is_visible), -1);
  rb_define_method(SwigClassMovableObject.klass, "set_rendering_distance", VALUEFUNC(_wrap_MovableObject_set_rendering_distance), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_rendering_distance", VALUEFUNC(_wrap_MovableObject_get_rendering_distance), -1);
  rb_define_method(SwigClassMovableObject.klass, "set_rendering_min_pixel_size", VALUEFUNC(_wrap_MovableObject_set_rendering_min_pixel_size), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_rendering_min_pixel_size", VALUEFUNC(_wrap_MovableObject_get_rendering_min_pixel_size), -1);
  rb_define_method(SwigClassMovableObject.klass, "set_user_any", VALUEFUNC(_wrap_MovableObject_set_user_any), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_user_any", VALUEFUNC(_wrap_MovableObject_get_user_any), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_user_object_bindings", VALUEFUNC(_wrap_MovableObject_get_user_object_bindings), -1);
  rb_define_method(SwigClassMovableObject.klass, "set_render_queue_group", VALUEFUNC(_wrap_MovableObject_set_render_queue_group), -1);
  rb_define_method(SwigClassMovableObject.klass, "set_render_queue_group_and_priority", VALUEFUNC(_wrap_MovableObject_set_render_queue_group_and_priority), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_render_queue_group", VALUEFUNC(_wrap_MovableObject_get_render_queue_group), -1);
  rb_define_method(SwigClassMovableObject.klass, "_get_parent_node_full_transform", VALUEFUNC(_wrap_MovableObject__get_parent_node_full_transform), -1);
  rb_define_method(SwigClassMovableObject.klass, "set_query_flags", VALUEFUNC(_wrap_MovableObject_set_query_flags), -1);
  rb_define_method(SwigClassMovableObject.klass, "add_query_flags", VALUEFUNC(_wrap_MovableObject_add_query_flags), -1);
  rb_define_method(SwigClassMovableObject.klass, "remove_query_flags", VALUEFUNC(_wrap_MovableObject_remove_query_flags), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_query_flags", VALUEFUNC(_wrap_MovableObject_get_query_flags), -1);
  rb_define_singleton_method(SwigClassMovableObject.klass, "set_default_query_flags", VALUEFUNC(_wrap_MovableObject_set_default_query_flags), -1);
  rb_define_singleton_method(SwigClassMovableObject.klass, "get_default_query_flags", VALUEFUNC(_wrap_MovableObject_get_default_query_flags), -1);
  rb_define_method(SwigClassMovableObject.klass, "set_visibility_flags", VALUEFUNC(_wrap_MovableObject_set_visibility_flags), -1);
  rb_define_method(SwigClassMovableObject.klass, "add_visibility_flags", VALUEFUNC(_wrap_MovableObject_add_visibility_flags), -1);
  rb_define_method(SwigClassMovableObject.klass, "remove_visibility_flags", VALUEFUNC(_wrap_MovableObject_remove_visibility_flags), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_visibility_flags", VALUEFUNC(_wrap_MovableObject_get_visibility_flags), -1);
  rb_define_singleton_method(SwigClassMovableObject.klass, "set_default_visibility_flags", VALUEFUNC(_wrap_MovableObject_set_default_visibility_flags), -1);
  rb_define_singleton_method(SwigClassMovableObject.klass, "get_default_visibility_flags", VALUEFUNC(_wrap_MovableObject_get_default_visibility_flags), -1);
  rb_define_method(SwigClassMovableObject.klass, "set_listener", VALUEFUNC(_wrap_MovableObject_set_listener), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_listener", VALUEFUNC(_wrap_MovableObject_get_listener), -1);
  rb_define_method(SwigClassMovableObject.klass, "query_lights", VALUEFUNC(_wrap_MovableObject_query_lights), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_light_mask", VALUEFUNC(_wrap_MovableObject_get_light_mask), -1);
  rb_define_method(SwigClassMovableObject.klass, "set_light_mask", VALUEFUNC(_wrap_MovableObject_set_light_mask), -1);
  rb_define_method(SwigClassMovableObject.klass, "_get_light_list", VALUEFUNC(_wrap_MovableObject__get_light_list), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_edge_list", VALUEFUNC(_wrap_MovableObject_get_edge_list), -1);
  rb_define_method(SwigClassMovableObject.klass, "has_edge_list", VALUEFUNC(_wrap_MovableObject_has_edge_list), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_shadow_volume_renderable_iterator", VALUEFUNC(_wrap_MovableObject_get_shadow_volume_renderable_iterator), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_light_cap_bounds", VALUEFUNC(_wrap_MovableObject_get_light_cap_bounds), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_dark_cap_bounds", VALUEFUNC(_wrap_MovableObject_get_dark_cap_bounds), -1);
  rb_define_method(SwigClassMovableObject.klass, "set_cast_shadows", VALUEFUNC(_wrap_MovableObject_set_cast_shadows), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_cast_shadows", VALUEFUNC(_wrap_MovableObject_get_cast_shadows), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_receives_shadows", VALUEFUNC(_wrap_MovableObject_get_receives_shadows), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_point_extrusion_distance", VALUEFUNC(_wrap_MovableObject_get_point_extrusion_distance), -1);
  rb_define_method(SwigClassMovableObject.klass, "get_type_flags", VALUEFUNC(_wrap_MovableObject_get_type_flags), -1);
  rb_define_method(SwigClassMovableObject.klass, "visit_renderables", VALUEFUNC(_wrap_MovableObject_visit_renderables), -1);
  rb_define_method(SwigClassMovableObject.klass, "set_debug_display_enabled", VALUEFUNC(_wrap_MovableObject_set_debug_display_enabled), -1);
  rb_define_method(SwigClassMovableObject.klass, "is_debug_display_enabled", VALUEFUNC(_wrap_MovableObject_is_debug_display_enabled), -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, "get_type", VALUEFUNC(_wrap_MovableObjectFactory_get_type), -1);
  rb_define_method(SwigClassMovableObjectFactory.klass, "create_instance", VALUEFUNC(_wrap_MovableObjectFactory_create_instance), -1);
  rb_define_method(SwigClassMovableObjectFactory.klass, "destroy_instance", VALUEFUNC(_wrap_MovableObjectFactory_destroy_instance), -1);
  rb_define_method(SwigClassMovableObjectFactory.klass, "request_type_flags", VALUEFUNC(_wrap_MovableObjectFactory_request_type_flags), -1);
  rb_define_method(SwigClassMovableObjectFactory.klass, "_notify_type_flags", VALUEFUNC(_wrap_MovableObjectFactory__notify_type_flags), -1);
  rb_define_method(SwigClassMovableObjectFactory.klass, "get_type_flags", VALUEFUNC(_wrap_MovableObjectFactory_get_type_flags), -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, "_notify_current_camera", VALUEFUNC(_wrap_MovablePlane__notify_current_camera), -1);
  rb_define_method(SwigClassMovablePlane.klass, "get_bounding_box", VALUEFUNC(_wrap_MovablePlane_get_bounding_box), -1);
  rb_define_method(SwigClassMovablePlane.klass, "get_bounding_radius", VALUEFUNC(_wrap_MovablePlane_get_bounding_radius), -1);
  rb_define_method(SwigClassMovablePlane.klass, "_update_render_queue", VALUEFUNC(_wrap_MovablePlane__update_render_queue), -1);
  rb_define_method(SwigClassMovablePlane.klass, "get_movable_type", VALUEFUNC(_wrap_MovablePlane_get_movable_type), -1);
  rb_define_method(SwigClassMovablePlane.klass, "_get_derived_plane", VALUEFUNC(_wrap_MovablePlane__get_derived_plane), -1);
  rb_define_method(SwigClassMovablePlane.klass, "visit_renderables", VALUEFUNC(_wrap_MovablePlane_visit_renderables), -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, "get_shadow_camera", VALUEFUNC(_wrap_ShadowCameraSetup_get_shadow_camera), -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, "get_shadow_camera", VALUEFUNC(_wrap_DefaultShadowCameraSetup_get_shadow_camera), -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, "_calc_temp_square_dist", VALUEFUNC(_wrap_Light__calc_temp_square_dist), -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, "set_type", VALUEFUNC(_wrap_Light_set_type), -1);
  rb_define_method(SwigClassLight.klass, "get_type", VALUEFUNC(_wrap_Light_get_type), -1);
  rb_define_method(SwigClassLight.klass, "set_diffuse_colour", VALUEFUNC(_wrap_Light_set_diffuse_colour), -1);
  rb_define_method(SwigClassLight.klass, "get_diffuse_colour", VALUEFUNC(_wrap_Light_get_diffuse_colour), -1);
  rb_define_method(SwigClassLight.klass, "set_specular_colour", VALUEFUNC(_wrap_Light_set_specular_colour), -1);
  rb_define_method(SwigClassLight.klass, "get_specular_colour", VALUEFUNC(_wrap_Light_get_specular_colour), -1);
  rb_define_method(SwigClassLight.klass, "set_attenuation", VALUEFUNC(_wrap_Light_set_attenuation), -1);
  rb_define_method(SwigClassLight.klass, "get_attenuation_range", VALUEFUNC(_wrap_Light_get_attenuation_range), -1);
  rb_define_method(SwigClassLight.klass, "get_attenuation_constant", VALUEFUNC(_wrap_Light_get_attenuation_constant), -1);
  rb_define_method(SwigClassLight.klass, "get_attenuation_linear", VALUEFUNC(_wrap_Light_get_attenuation_linear), -1);
  rb_define_method(SwigClassLight.klass, "get_attenuation_quadric", VALUEFUNC(_wrap_Light_get_attenuation_quadric), -1);
  rb_define_method(SwigClassLight.klass, "set_position", VALUEFUNC(_wrap_Light_set_position), -1);
  rb_define_method(SwigClassLight.klass, "get_position", VALUEFUNC(_wrap_Light_get_position), -1);
  rb_define_method(SwigClassLight.klass, "set_direction", VALUEFUNC(_wrap_Light_set_direction), -1);
  rb_define_method(SwigClassLight.klass, "get_direction", VALUEFUNC(_wrap_Light_get_direction), -1);
  rb_define_method(SwigClassLight.klass, "set_spotlight_range", VALUEFUNC(_wrap_Light_set_spotlight_range), -1);
  rb_define_method(SwigClassLight.klass, "get_spotlight_inner_angle", VALUEFUNC(_wrap_Light_get_spotlight_inner_angle), -1);
  rb_define_method(SwigClassLight.klass, "get_spotlight_outer_angle", VALUEFUNC(_wrap_Light_get_spotlight_outer_angle), -1);
  rb_define_method(SwigClassLight.klass, "get_spotlight_falloff", VALUEFUNC(_wrap_Light_get_spotlight_falloff), -1);
  rb_define_method(SwigClassLight.klass, "set_spotlight_inner_angle", VALUEFUNC(_wrap_Light_set_spotlight_inner_angle), -1);
  rb_define_method(SwigClassLight.klass, "set_spotlight_outer_angle", VALUEFUNC(_wrap_Light_set_spotlight_outer_angle), -1);
  rb_define_method(SwigClassLight.klass, "set_spotlight_falloff", VALUEFUNC(_wrap_Light_set_spotlight_falloff), -1);
  rb_define_method(SwigClassLight.klass, "set_spotlight_near_clip_distance", VALUEFUNC(_wrap_Light_set_spotlight_near_clip_distance), -1);
  rb_define_method(SwigClassLight.klass, "get_spotlight_near_clip_distance", VALUEFUNC(_wrap_Light_get_spotlight_near_clip_distance), -1);
  rb_define_method(SwigClassLight.klass, "set_power_scale", VALUEFUNC(_wrap_Light_set_power_scale), -1);
  rb_define_method(SwigClassLight.klass, "get_power_scale", VALUEFUNC(_wrap_Light_get_power_scale), -1);
  rb_define_method(SwigClassLight.klass, "_notify_attached", VALUEFUNC(_wrap_Light__notify_attached), -1);
  rb_define_method(SwigClassLight.klass, "_notify_moved", VALUEFUNC(_wrap_Light__notify_moved), -1);
  rb_define_method(SwigClassLight.klass, "get_bounding_box", VALUEFUNC(_wrap_Light_get_bounding_box), -1);
  rb_define_method(SwigClassLight.klass, "_update_render_queue", VALUEFUNC(_wrap_Light__update_render_queue), -1);
  rb_define_method(SwigClassLight.klass, "get_movable_type", VALUEFUNC(_wrap_Light_get_movable_type), -1);
  rb_define_method(SwigClassLight.klass, "get_derived_position", VALUEFUNC(_wrap_Light_get_derived_position), -1);
  rb_define_method(SwigClassLight.klass, "get_derived_direction", VALUEFUNC(_wrap_Light_get_derived_direction), -1);
  rb_define_method(SwigClassLight.klass, "set_visible", VALUEFUNC(_wrap_Light_set_visible), -1);
  rb_define_method(SwigClassLight.klass, "get_bounding_radius", VALUEFUNC(_wrap_Light_get_bounding_radius), -1);
  rb_define_method(SwigClassLight.klass, "get_as_4dvector", VALUEFUNC(_wrap_Light_get_as_4dvector), -1);
  rb_define_method(SwigClassLight.klass, "_get_near_clip_volume", VALUEFUNC(_wrap_Light__get_near_clip_volume), -1);
  rb_define_method(SwigClassLight.klass, "_get_frustum_clip_volumes", VALUEFUNC(_wrap_Light__get_frustum_clip_volumes), -1);
  rb_define_method(SwigClassLight.klass, "get_type_flags", VALUEFUNC(_wrap_Light_get_type_flags), -1);
  rb_define_method(SwigClassLight.klass, "create_animable_value", VALUEFUNC(_wrap_Light_create_animable_value), -1);
  rb_define_method(SwigClassLight.klass, "set_custom_shadow_camera_setup", VALUEFUNC(_wrap_Light_set_custom_shadow_camera_setup), -1);
  rb_define_method(SwigClassLight.klass, "reset_custom_shadow_camera_setup", VALUEFUNC(_wrap_Light_reset_custom_shadow_camera_setup), -1);
  rb_define_method(SwigClassLight.klass, "get_custom_shadow_camera_setup", VALUEFUNC(_wrap_Light_get_custom_shadow_camera_setup), -1);
  rb_define_method(SwigClassLight.klass, "visit_renderables", VALUEFUNC(_wrap_Light_visit_renderables), -1);
  rb_define_method(SwigClassLight.klass, "_get_index_in_frame", VALUEFUNC(_wrap_Light__get_index_in_frame), -1);
  rb_define_method(SwigClassLight.klass, "_notify_index_in_frame", VALUEFUNC(_wrap_Light__notify_index_in_frame), -1);
  rb_define_method(SwigClassLight.klass, "set_shadow_far_distance", VALUEFUNC(_wrap_Light_set_shadow_far_distance), -1);
  rb_define_method(SwigClassLight.klass, "reset_shadow_far_distance", VALUEFUNC(_wrap_Light_reset_shadow_far_distance), -1);
  rb_define_method(SwigClassLight.klass, "get_shadow_far_distance", VALUEFUNC(_wrap_Light_get_shadow_far_distance), -1);
  rb_define_method(SwigClassLight.klass, "get_shadow_far_distance_squared", VALUEFUNC(_wrap_Light_get_shadow_far_distance_squared), -1);
  rb_define_method(SwigClassLight.klass, "set_shadow_near_clip_distance", VALUEFUNC(_wrap_Light_set_shadow_near_clip_distance), -1);
  rb_define_method(SwigClassLight.klass, "get_shadow_near_clip_distance", VALUEFUNC(_wrap_Light_get_shadow_near_clip_distance), -1);
  rb_define_method(SwigClassLight.klass, "_derive_shadow_near_clip_distance", VALUEFUNC(_wrap_Light__derive_shadow_near_clip_distance), -1);
  rb_define_method(SwigClassLight.klass, "set_shadow_far_clip_distance", VALUEFUNC(_wrap_Light_set_shadow_far_clip_distance), -1);
  rb_define_method(SwigClassLight.klass, "get_shadow_far_clip_distance", VALUEFUNC(_wrap_Light_get_shadow_far_clip_distance), -1);
  rb_define_method(SwigClassLight.klass, "_derive_shadow_far_clip_distance", VALUEFUNC(_wrap_Light__derive_shadow_far_clip_distance), -1);
  rb_define_method(SwigClassLight.klass, "_set_camera_relative", VALUEFUNC(_wrap_Light__set_camera_relative), -1);
  rb_define_method(SwigClassLight.klass, "set_custom_parameter", VALUEFUNC(_wrap_Light_set_custom_parameter), -1);
  rb_define_method(SwigClassLight.klass, "get_custom_parameter", VALUEFUNC(_wrap_Light_get_custom_parameter), -1);
  rb_define_method(SwigClassLight.klass, "_update_custom_gpu_parameter", VALUEFUNC(_wrap_Light__update_custom_gpu_parameter), -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, "get_type", VALUEFUNC(_wrap_LightFactory_get_type), -1);
  rb_define_method(SwigClassLightFactory.klass, "destroy_instance", VALUEFUNC(_wrap_LightFactory_destroy_instance), -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, "set_current_renderable", VALUEFUNC(_wrap_AutoParamDataSource_set_current_renderable), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_world_matrices", VALUEFUNC(_wrap_AutoParamDataSource_set_world_matrices), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_current_camera", VALUEFUNC(_wrap_AutoParamDataSource_set_current_camera), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_current_light_list", VALUEFUNC(_wrap_AutoParamDataSource_set_current_light_list), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_texture_projector", VALUEFUNC(_wrap_AutoParamDataSource_set_texture_projector), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_current_render_target", VALUEFUNC(_wrap_AutoParamDataSource_set_current_render_target), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_current_viewport", VALUEFUNC(_wrap_AutoParamDataSource_set_current_viewport), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_shadow_dir_light_extrusion_distance", VALUEFUNC(_wrap_AutoParamDataSource_set_shadow_dir_light_extrusion_distance), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_main_cam_bounds_info", VALUEFUNC(_wrap_AutoParamDataSource_set_main_cam_bounds_info), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_current_scene_manager", VALUEFUNC(_wrap_AutoParamDataSource_set_current_scene_manager), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_current_pass", VALUEFUNC(_wrap_AutoParamDataSource_set_current_pass), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_world_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_world_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_world_matrix_array", VALUEFUNC(_wrap_AutoParamDataSource_get_world_matrix_array), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_world_matrix_count", VALUEFUNC(_wrap_AutoParamDataSource_get_world_matrix_count), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_view_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_view_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_view_projection_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_view_projection_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_projection_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_projection_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_world_view_proj_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_world_view_proj_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_world_view_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_world_view_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_world_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_world_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_world_view_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_world_view_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_view_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_view_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_transpose_world_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_transpose_world_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_transpose_world_view_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_transpose_world_view_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_camera_position", VALUEFUNC(_wrap_AutoParamDataSource_get_camera_position), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_camera_position_object_space", VALUEFUNC(_wrap_AutoParamDataSource_get_camera_position_object_space), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_lod_camera_position", VALUEFUNC(_wrap_AutoParamDataSource_get_lod_camera_position), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_lod_camera_position_object_space", VALUEFUNC(_wrap_AutoParamDataSource_get_lod_camera_position_object_space), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "has_light_list", VALUEFUNC(_wrap_AutoParamDataSource_has_light_list), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_light_number", VALUEFUNC(_wrap_AutoParamDataSource_get_light_number), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_light_count", VALUEFUNC(_wrap_AutoParamDataSource_get_light_count), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_light_casts_shadows", VALUEFUNC(_wrap_AutoParamDataSource_get_light_casts_shadows), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_light_diffuse_colour", VALUEFUNC(_wrap_AutoParamDataSource_get_light_diffuse_colour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_light_specular_colour", VALUEFUNC(_wrap_AutoParamDataSource_get_light_specular_colour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_light_diffuse_colour_with_power", VALUEFUNC(_wrap_AutoParamDataSource_get_light_diffuse_colour_with_power), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_light_specular_colour_with_power", VALUEFUNC(_wrap_AutoParamDataSource_get_light_specular_colour_with_power), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_light_position", VALUEFUNC(_wrap_AutoParamDataSource_get_light_position), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_light_as_4dvector", VALUEFUNC(_wrap_AutoParamDataSource_get_light_as_4dvector), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_light_direction", VALUEFUNC(_wrap_AutoParamDataSource_get_light_direction), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_light_power_scale", VALUEFUNC(_wrap_AutoParamDataSource_get_light_power_scale), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_light_attenuation", VALUEFUNC(_wrap_AutoParamDataSource_get_light_attenuation), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_spotlight_params", VALUEFUNC(_wrap_AutoParamDataSource_get_spotlight_params), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_ambient_light_colour", VALUEFUNC(_wrap_AutoParamDataSource_set_ambient_light_colour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_ambient_light_colour", VALUEFUNC(_wrap_AutoParamDataSource_get_ambient_light_colour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_surface_ambient_colour", VALUEFUNC(_wrap_AutoParamDataSource_get_surface_ambient_colour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_surface_diffuse_colour", VALUEFUNC(_wrap_AutoParamDataSource_get_surface_diffuse_colour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_surface_specular_colour", VALUEFUNC(_wrap_AutoParamDataSource_get_surface_specular_colour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_surface_emissive_colour", VALUEFUNC(_wrap_AutoParamDataSource_get_surface_emissive_colour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_surface_shininess", VALUEFUNC(_wrap_AutoParamDataSource_get_surface_shininess), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_derived_ambient_light_colour", VALUEFUNC(_wrap_AutoParamDataSource_get_derived_ambient_light_colour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_derived_scene_colour", VALUEFUNC(_wrap_AutoParamDataSource_get_derived_scene_colour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_fog", VALUEFUNC(_wrap_AutoParamDataSource_set_fog), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_fog_colour", VALUEFUNC(_wrap_AutoParamDataSource_get_fog_colour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_fog_params", VALUEFUNC(_wrap_AutoParamDataSource_get_fog_params), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_texture_view_proj_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_texture_view_proj_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_texture_world_view_proj_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_texture_world_view_proj_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_spotlight_view_proj_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_spotlight_view_proj_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_spotlight_world_view_proj_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_spotlight_world_view_proj_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_texture_transform_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_texture_transform_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_current_render_target", VALUEFUNC(_wrap_AutoParamDataSource_get_current_render_target), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_current_renderable", VALUEFUNC(_wrap_AutoParamDataSource_get_current_renderable), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_current_pass", VALUEFUNC(_wrap_AutoParamDataSource_get_current_pass), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_texture_size", VALUEFUNC(_wrap_AutoParamDataSource_get_texture_size), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_texture_size", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_texture_size), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_packed_texture_size", VALUEFUNC(_wrap_AutoParamDataSource_get_packed_texture_size), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_shadow_extrusion_distance", VALUEFUNC(_wrap_AutoParamDataSource_get_shadow_extrusion_distance), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_scene_depth_range", VALUEFUNC(_wrap_AutoParamDataSource_get_scene_depth_range), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_shadow_scene_depth_range", VALUEFUNC(_wrap_AutoParamDataSource_get_shadow_scene_depth_range), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_shadow_colour", VALUEFUNC(_wrap_AutoParamDataSource_get_shadow_colour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_view_proj_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_view_proj_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_transpose_view_proj_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_transpose_view_proj_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_transpose_view_proj_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_transpose_view_proj_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_transpose_view_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_transpose_view_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_transpose_view_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_transpose_view_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_transpose_projection_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_transpose_projection_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_projection_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_projection_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_transpose_projection_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_transpose_projection_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_transpose_world_view_proj_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_transpose_world_view_proj_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_world_view_proj_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_world_view_proj_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_transpose_world_view_proj_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_transpose_world_view_proj_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_transpose_world_view_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_transpose_world_view_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_transpose_world_matrix", VALUEFUNC(_wrap_AutoParamDataSource_get_transpose_world_matrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_time", VALUEFUNC(_wrap_AutoParamDataSource_get_time), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_time_0_x", VALUEFUNC(_wrap_AutoParamDataSource_get_time_0_x), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_cos_time_0_x", VALUEFUNC(_wrap_AutoParamDataSource_get_cos_time_0_x), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_sin_time_0_x", VALUEFUNC(_wrap_AutoParamDataSource_get_sin_time_0_x), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_tan_time_0_x", VALUEFUNC(_wrap_AutoParamDataSource_get_tan_time_0_x), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_time_0_x_packed", VALUEFUNC(_wrap_AutoParamDataSource_get_time_0_x_packed), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_time_0_1", VALUEFUNC(_wrap_AutoParamDataSource_get_time_0_1), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_cos_time_0_1", VALUEFUNC(_wrap_AutoParamDataSource_get_cos_time_0_1), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_sin_time_0_1", VALUEFUNC(_wrap_AutoParamDataSource_get_sin_time_0_1), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_tan_time_0_1", VALUEFUNC(_wrap_AutoParamDataSource_get_tan_time_0_1), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_time_0_1_packed", VALUEFUNC(_wrap_AutoParamDataSource_get_time_0_1_packed), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_time_0_2pi", VALUEFUNC(_wrap_AutoParamDataSource_get_time_0_2pi), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_cos_time_0_2pi", VALUEFUNC(_wrap_AutoParamDataSource_get_cos_time_0_2pi), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_sin_time_0_2pi", VALUEFUNC(_wrap_AutoParamDataSource_get_sin_time_0_2pi), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_tan_time_0_2pi", VALUEFUNC(_wrap_AutoParamDataSource_get_tan_time_0_2pi), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_time_0_2pi_packed", VALUEFUNC(_wrap_AutoParamDataSource_get_time_0_2pi_packed), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_frame_time", VALUEFUNC(_wrap_AutoParamDataSource_get_frame_time), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_fps", VALUEFUNC(_wrap_AutoParamDataSource_get_fps), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_viewport_width", VALUEFUNC(_wrap_AutoParamDataSource_get_viewport_width), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_viewport_height", VALUEFUNC(_wrap_AutoParamDataSource_get_viewport_height), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_viewport_width", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_viewport_width), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_inverse_viewport_height", VALUEFUNC(_wrap_AutoParamDataSource_get_inverse_viewport_height), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_view_direction", VALUEFUNC(_wrap_AutoParamDataSource_get_view_direction), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_view_side_vector", VALUEFUNC(_wrap_AutoParamDataSource_get_view_side_vector), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_view_up_vector", VALUEFUNC(_wrap_AutoParamDataSource_get_view_up_vector), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_fov", VALUEFUNC(_wrap_AutoParamDataSource_get_fov), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_near_clip_distance", VALUEFUNC(_wrap_AutoParamDataSource_get_near_clip_distance), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_far_clip_distance", VALUEFUNC(_wrap_AutoParamDataSource_get_far_clip_distance), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "get_pass_number", VALUEFUNC(_wrap_AutoParamDataSource_get_pass_number), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "set_pass_number", VALUEFUNC(_wrap_AutoParamDataSource_set_pass_number), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "inc_pass_number", VALUEFUNC(_wrap_AutoParamDataSource_inc_pass_number), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "update_light_custom_gpu_parameter", VALUEFUNC(_wrap_AutoParamDataSource_update_light_custom_gpu_parameter), -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, "get_rotation", VALUEFUNC(_wrap_Billboard_get_rotation), -1);
  rb_define_method(SwigClassBillboard.klass, "set_rotation", VALUEFUNC(_wrap_Billboard_set_rotation), -1);
  rb_define_method(SwigClassBillboard.klass, "set_position", VALUEFUNC(_wrap_Billboard_set_position), -1);
  rb_define_method(SwigClassBillboard.klass, "get_position", VALUEFUNC(_wrap_Billboard_get_position), -1);
  rb_define_method(SwigClassBillboard.klass, "set_dimensions", VALUEFUNC(_wrap_Billboard_set_dimensions), -1);
  rb_define_method(SwigClassBillboard.klass, "reset_dimensions", VALUEFUNC(_wrap_Billboard_reset_dimensions), -1);
  rb_define_method(SwigClassBillboard.klass, "set_colour", VALUEFUNC(_wrap_Billboard_set_colour), -1);
  rb_define_method(SwigClassBillboard.klass, "get_colour", VALUEFUNC(_wrap_Billboard_get_colour), -1);
  rb_define_method(SwigClassBillboard.klass, "has_own_dimensions", VALUEFUNC(_wrap_Billboard_has_own_dimensions), -1);
  rb_define_method(SwigClassBillboard.klass, "get_own_width", VALUEFUNC(_wrap_Billboard_get_own_width), -1);
  rb_define_method(SwigClassBillboard.klass, "get_own_height", VALUEFUNC(_wrap_Billboard_get_own_height), -1);
  rb_define_method(SwigClassBillboard.klass, "_notify_owner", VALUEFUNC(_wrap_Billboard__notify_owner), -1);
  rb_define_method(SwigClassBillboard.klass, "is_use_texcoord_rect", VALUEFUNC(_wrap_Billboard_is_use_texcoord_rect), -1);
  rb_define_method(SwigClassBillboard.klass, "set_texcoord_index", VALUEFUNC(_wrap_Billboard_set_texcoord_index), -1);
  rb_define_method(SwigClassBillboard.klass, "get_texcoord_index", VALUEFUNC(_wrap_Billboard_get_texcoord_index), -1);
  rb_define_method(SwigClassBillboard.klass, "set_texcoord_rect", VALUEFUNC(_wrap_Billboard_set_texcoord_rect), -1);
  rb_define_method(SwigClassBillboard.klass, "get_texcoord_rect", VALUEFUNC(_wrap_Billboard_get_texcoord_rect), -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, "set_max_chain_elements", VALUEFUNC(_wrap_BillboardChain_set_max_chain_elements), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_max_chain_elements", VALUEFUNC(_wrap_BillboardChain_get_max_chain_elements), -1);
  rb_define_method(SwigClassBillboardChain.klass, "set_number_of_chains", VALUEFUNC(_wrap_BillboardChain_set_number_of_chains), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_number_of_chains", VALUEFUNC(_wrap_BillboardChain_get_number_of_chains), -1);
  rb_define_method(SwigClassBillboardChain.klass, "set_use_texture_coords", VALUEFUNC(_wrap_BillboardChain_set_use_texture_coords), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_use_texture_coords", VALUEFUNC(_wrap_BillboardChain_get_use_texture_coords), -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, "set_texture_coord_direction", VALUEFUNC(_wrap_BillboardChain_set_texture_coord_direction), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_texture_coord_direction", VALUEFUNC(_wrap_BillboardChain_get_texture_coord_direction), -1);
  rb_define_method(SwigClassBillboardChain.klass, "set_other_texture_coord_range", VALUEFUNC(_wrap_BillboardChain_set_other_texture_coord_range), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_other_texture_coord_range", VALUEFUNC(_wrap_BillboardChain_get_other_texture_coord_range), -1);
  rb_define_method(SwigClassBillboardChain.klass, "set_use_vertex_colours", VALUEFUNC(_wrap_BillboardChain_set_use_vertex_colours), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_use_vertex_colours", VALUEFUNC(_wrap_BillboardChain_get_use_vertex_colours), -1);
  rb_define_method(SwigClassBillboardChain.klass, "set_dynamic", VALUEFUNC(_wrap_BillboardChain_set_dynamic), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_dynamic", VALUEFUNC(_wrap_BillboardChain_get_dynamic), -1);
  rb_define_method(SwigClassBillboardChain.klass, "add_chain_element", VALUEFUNC(_wrap_BillboardChain_add_chain_element), -1);
  rb_define_method(SwigClassBillboardChain.klass, "remove_chain_element", VALUEFUNC(_wrap_BillboardChain_remove_chain_element), -1);
  rb_define_method(SwigClassBillboardChain.klass, "update_chain_element", VALUEFUNC(_wrap_BillboardChain_update_chain_element), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_chain_element", VALUEFUNC(_wrap_BillboardChain_get_chain_element), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_num_chain_elements", VALUEFUNC(_wrap_BillboardChain_get_num_chain_elements), -1);
  rb_define_method(SwigClassBillboardChain.klass, "clear_chain", VALUEFUNC(_wrap_BillboardChain_clear_chain), -1);
  rb_define_method(SwigClassBillboardChain.klass, "clear_all_chains", VALUEFUNC(_wrap_BillboardChain_clear_all_chains), -1);
  rb_define_method(SwigClassBillboardChain.klass, "set_face_camera", VALUEFUNC(_wrap_BillboardChain_set_face_camera), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_material_name", VALUEFUNC(_wrap_BillboardChain_get_material_name), -1);
  rb_define_method(SwigClassBillboardChain.klass, "set_material_name", VALUEFUNC(_wrap_BillboardChain_set_material_name), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_squared_view_depth", VALUEFUNC(_wrap_BillboardChain_get_squared_view_depth), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_bounding_radius", VALUEFUNC(_wrap_BillboardChain_get_bounding_radius), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_bounding_box", VALUEFUNC(_wrap_BillboardChain_get_bounding_box), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_material", VALUEFUNC(_wrap_BillboardChain_get_material), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_movable_type", VALUEFUNC(_wrap_BillboardChain_get_movable_type), -1);
  rb_define_method(SwigClassBillboardChain.klass, "_update_render_queue", VALUEFUNC(_wrap_BillboardChain__update_render_queue), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_render_operation", VALUEFUNC(_wrap_BillboardChain_get_render_operation), -1);
  rb_define_method(SwigClassBillboardChain.klass, "pre_render", VALUEFUNC(_wrap_BillboardChain_pre_render), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_world_transforms", VALUEFUNC(_wrap_BillboardChain_get_world_transforms), -1);
  rb_define_method(SwigClassBillboardChain.klass, "get_lights", VALUEFUNC(_wrap_BillboardChain_get_lights), -1);
  rb_define_method(SwigClassBillboardChain.klass, "visit_renderables", VALUEFUNC(_wrap_BillboardChain_visit_renderables), -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, "get_type", VALUEFUNC(_wrap_BillboardChainFactory_get_type), -1);
  rb_define_method(SwigClassBillboardChainFactory.klass, "destroy_instance", VALUEFUNC(_wrap_BillboardChainFactory_destroy_instance), -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, "get_type", VALUEFUNC(_wrap_ParticleSystemRenderer_get_type), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_update_render_queue", VALUEFUNC(_wrap_ParticleSystemRenderer__update_render_queue), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_set_material", VALUEFUNC(_wrap_ParticleSystemRenderer__set_material), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notify_current_camera", VALUEFUNC(_wrap_ParticleSystemRenderer__notify_current_camera), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notify_attached", VALUEFUNC(_wrap_ParticleSystemRenderer__notify_attached), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notify_particle_rotated", VALUEFUNC(_wrap_ParticleSystemRenderer__notify_particle_rotated), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notify_particle_resized", VALUEFUNC(_wrap_ParticleSystemRenderer__notify_particle_resized), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notify_particle_quota", VALUEFUNC(_wrap_ParticleSystemRenderer__notify_particle_quota), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notify_default_dimensions", VALUEFUNC(_wrap_ParticleSystemRenderer__notify_default_dimensions), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notify_particle_emitted", VALUEFUNC(_wrap_ParticleSystemRenderer__notify_particle_emitted), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notify_particle_expired", VALUEFUNC(_wrap_ParticleSystemRenderer__notify_particle_expired), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notify_particle_moved", VALUEFUNC(_wrap_ParticleSystemRenderer__notify_particle_moved), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notify_particle_cleared", VALUEFUNC(_wrap_ParticleSystemRenderer__notify_particle_cleared), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_create_visual_data", VALUEFUNC(_wrap_ParticleSystemRenderer__create_visual_data), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_destroy_visual_data", VALUEFUNC(_wrap_ParticleSystemRenderer__destroy_visual_data), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "set_render_queue_group", VALUEFUNC(_wrap_ParticleSystemRenderer_set_render_queue_group), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "set_render_queue_group_and_priority", VALUEFUNC(_wrap_ParticleSystemRenderer_set_render_queue_group_and_priority), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "set_keep_particles_in_local_space", VALUEFUNC(_wrap_ParticleSystemRenderer_set_keep_particles_in_local_space), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_get_sort_mode", VALUEFUNC(_wrap_ParticleSystemRenderer__get_sort_mode), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "visit_renderables", VALUEFUNC(_wrap_ParticleSystemRenderer_visit_renderables), -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, "create_billboard", VALUEFUNC(_wrap_BillboardSet_create_billboard), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_num_billboards", VALUEFUNC(_wrap_BillboardSet_get_num_billboards), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_autoextend", VALUEFUNC(_wrap_BillboardSet_set_autoextend), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_autoextend", VALUEFUNC(_wrap_BillboardSet_get_autoextend), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_sorting_enabled", VALUEFUNC(_wrap_BillboardSet_set_sorting_enabled), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_sorting_enabled", VALUEFUNC(_wrap_BillboardSet_get_sorting_enabled), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_pool_size", VALUEFUNC(_wrap_BillboardSet_set_pool_size), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_pool_size", VALUEFUNC(_wrap_BillboardSet_get_pool_size), -1);
  rb_define_method(SwigClassBillboardSet.klass, "clear", VALUEFUNC(_wrap_BillboardSet_clear), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_billboard", VALUEFUNC(_wrap_BillboardSet_get_billboard), -1);
  rb_define_method(SwigClassBillboardSet.klass, "remove_billboard", VALUEFUNC(_wrap_BillboardSet_remove_billboard), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_billboard_origin", VALUEFUNC(_wrap_BillboardSet_set_billboard_origin), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_billboard_origin", VALUEFUNC(_wrap_BillboardSet_get_billboard_origin), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_billboard_rotation_type", VALUEFUNC(_wrap_BillboardSet_set_billboard_rotation_type), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_billboard_rotation_type", VALUEFUNC(_wrap_BillboardSet_get_billboard_rotation_type), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_default_dimensions", VALUEFUNC(_wrap_BillboardSet_set_default_dimensions), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_default_width", VALUEFUNC(_wrap_BillboardSet_set_default_width), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_default_width", VALUEFUNC(_wrap_BillboardSet_get_default_width), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_default_height", VALUEFUNC(_wrap_BillboardSet_set_default_height), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_default_height", VALUEFUNC(_wrap_BillboardSet_get_default_height), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_material_name", VALUEFUNC(_wrap_BillboardSet_set_material_name), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_material_name", VALUEFUNC(_wrap_BillboardSet_get_material_name), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_notify_current_camera", VALUEFUNC(_wrap_BillboardSet__notify_current_camera), -1);
  rb_define_method(SwigClassBillboardSet.klass, "begin_billboards", VALUEFUNC(_wrap_BillboardSet_begin_billboards), -1);
  rb_define_method(SwigClassBillboardSet.klass, "inject_billboard", VALUEFUNC(_wrap_BillboardSet_inject_billboard), -1);
  rb_define_method(SwigClassBillboardSet.klass, "end_billboards", VALUEFUNC(_wrap_BillboardSet_end_billboards), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_bounds", VALUEFUNC(_wrap_BillboardSet_set_bounds), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_bounding_box", VALUEFUNC(_wrap_BillboardSet_get_bounding_box), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_bounding_radius", VALUEFUNC(_wrap_BillboardSet_get_bounding_radius), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_update_render_queue", VALUEFUNC(_wrap_BillboardSet__update_render_queue), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_material", VALUEFUNC(_wrap_BillboardSet_get_material), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_material", VALUEFUNC(_wrap_BillboardSet_set_material), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_render_operation", VALUEFUNC(_wrap_BillboardSet_get_render_operation), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_world_transforms", VALUEFUNC(_wrap_BillboardSet_get_world_transforms), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_notify_billboard_resized", VALUEFUNC(_wrap_BillboardSet__notify_billboard_resized), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_notify_billboard_rotated", VALUEFUNC(_wrap_BillboardSet__notify_billboard_rotated), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_cull_individually", VALUEFUNC(_wrap_BillboardSet_get_cull_individually), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_cull_individually", VALUEFUNC(_wrap_BillboardSet_set_cull_individually), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_billboard_type", VALUEFUNC(_wrap_BillboardSet_set_billboard_type), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_billboard_type", VALUEFUNC(_wrap_BillboardSet_get_billboard_type), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_common_direction", VALUEFUNC(_wrap_BillboardSet_set_common_direction), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_common_direction", VALUEFUNC(_wrap_BillboardSet_get_common_direction), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_common_up_vector", VALUEFUNC(_wrap_BillboardSet_set_common_up_vector), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_common_up_vector", VALUEFUNC(_wrap_BillboardSet_get_common_up_vector), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_use_accurate_facing", VALUEFUNC(_wrap_BillboardSet_set_use_accurate_facing), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_use_accurate_facing", VALUEFUNC(_wrap_BillboardSet_get_use_accurate_facing), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_movable_type", VALUEFUNC(_wrap_BillboardSet_get_movable_type), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_squared_view_depth", VALUEFUNC(_wrap_BillboardSet_get_squared_view_depth), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_update_bounds", VALUEFUNC(_wrap_BillboardSet__update_bounds), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_lights", VALUEFUNC(_wrap_BillboardSet_get_lights), -1);
  rb_define_method(SwigClassBillboardSet.klass, "visit_renderables", VALUEFUNC(_wrap_BillboardSet_visit_renderables), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_sort_billboards", VALUEFUNC(_wrap_BillboardSet__sort_billboards), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_get_sort_mode", VALUEFUNC(_wrap_BillboardSet__get_sort_mode), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_billboards_in_world_space", VALUEFUNC(_wrap_BillboardSet_set_billboards_in_world_space), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_texture_coords", VALUEFUNC(_wrap_BillboardSet_set_texture_coords), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_texture_stacks_and_slices", VALUEFUNC(_wrap_BillboardSet_set_texture_stacks_and_slices), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_texture_coords", VALUEFUNC(_wrap_BillboardSet_get_texture_coords), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_point_rendering_enabled", VALUEFUNC(_wrap_BillboardSet_set_point_rendering_enabled), -1);
  rb_define_method(SwigClassBillboardSet.klass, "is_point_rendering_enabled", VALUEFUNC(_wrap_BillboardSet_is_point_rendering_enabled), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_type_flags", VALUEFUNC(_wrap_BillboardSet_get_type_flags), -1);
  rb_define_method(SwigClassBillboardSet.klass, "set_auto_update", VALUEFUNC(_wrap_BillboardSet_set_auto_update), -1);
  rb_define_method(SwigClassBillboardSet.klass, "get_auto_update", VALUEFUNC(_wrap_BillboardSet_get_auto_update), -1);
  rb_define_method(SwigClassBillboardSet.klass, "notify_billboard_data_changed", VALUEFUNC(_wrap_BillboardSet_notify_billboard_data_changed), -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, "get_type", VALUEFUNC(_wrap_BillboardSetFactory_get_type), -1);
  rb_define_method(SwigClassBillboardSetFactory.klass, "destroy_instance", VALUEFUNC(_wrap_BillboardSetFactory_destroy_instance), -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, "set_billboard_type", VALUEFUNC(_wrap_BillboardParticleRenderer_set_billboard_type), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "get_billboard_type", VALUEFUNC(_wrap_BillboardParticleRenderer_get_billboard_type), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "set_use_accurate_facing", VALUEFUNC(_wrap_BillboardParticleRenderer_set_use_accurate_facing), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "get_use_accurate_facing", VALUEFUNC(_wrap_BillboardParticleRenderer_get_use_accurate_facing), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "set_billboard_origin", VALUEFUNC(_wrap_BillboardParticleRenderer_set_billboard_origin), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "get_billboard_origin", VALUEFUNC(_wrap_BillboardParticleRenderer_get_billboard_origin), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "set_billboard_rotation_type", VALUEFUNC(_wrap_BillboardParticleRenderer_set_billboard_rotation_type), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "get_billboard_rotation_type", VALUEFUNC(_wrap_BillboardParticleRenderer_get_billboard_rotation_type), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "set_common_direction", VALUEFUNC(_wrap_BillboardParticleRenderer_set_common_direction), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "get_common_direction", VALUEFUNC(_wrap_BillboardParticleRenderer_get_common_direction), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "set_common_up_vector", VALUEFUNC(_wrap_BillboardParticleRenderer_set_common_up_vector), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "get_common_up_vector", VALUEFUNC(_wrap_BillboardParticleRenderer_get_common_up_vector), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "set_point_rendering_enabled", VALUEFUNC(_wrap_BillboardParticleRenderer_set_point_rendering_enabled), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "is_point_rendering_enabled", VALUEFUNC(_wrap_BillboardParticleRenderer_is_point_rendering_enabled), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "get_type", VALUEFUNC(_wrap_BillboardParticleRenderer_get_type), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_update_render_queue", VALUEFUNC(_wrap_BillboardParticleRenderer__update_render_queue), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "visit_renderables", VALUEFUNC(_wrap_BillboardParticleRenderer_visit_renderables), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_set_material", VALUEFUNC(_wrap_BillboardParticleRenderer__set_material), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_notify_current_camera", VALUEFUNC(_wrap_BillboardParticleRenderer__notify_current_camera), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_notify_particle_rotated", VALUEFUNC(_wrap_BillboardParticleRenderer__notify_particle_rotated), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_notify_particle_resized", VALUEFUNC(_wrap_BillboardParticleRenderer__notify_particle_resized), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_notify_particle_quota", VALUEFUNC(_wrap_BillboardParticleRenderer__notify_particle_quota), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_notify_attached", VALUEFUNC(_wrap_BillboardParticleRenderer__notify_attached), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_notify_default_dimensions", VALUEFUNC(_wrap_BillboardParticleRenderer__notify_default_dimensions), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "set_render_queue_group", VALUEFUNC(_wrap_BillboardParticleRenderer_set_render_queue_group), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "set_render_queue_group_and_priority", VALUEFUNC(_wrap_BillboardParticleRenderer_set_render_queue_group_and_priority), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "set_keep_particles_in_local_space", VALUEFUNC(_wrap_BillboardParticleRenderer_set_keep_particles_in_local_space), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_get_sort_mode", VALUEFUNC(_wrap_BillboardParticleRenderer__get_sort_mode), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "get_billboard_set", VALUEFUNC(_wrap_BillboardParticleRenderer_get_billboard_set), -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, "get_type", VALUEFUNC(_wrap_BillboardParticleRendererFactory_get_type), -1);
  rb_define_method(SwigClassBillboardParticleRendererFactory.klass, "create_instance", VALUEFUNC(_wrap_BillboardParticleRendererFactory_create_instance), -1);
  rb_define_method(SwigClassBillboardParticleRendererFactory.klass, "destroy_instance", VALUEFUNC(_wrap_BillboardParticleRendererFactory_destroy_instance), -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, "most_significant_bit_set", VALUEFUNC(_wrap_Bitwise_most_significant_bit_set), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "first_po_2from", VALUEFUNC(_wrap_Bitwise_first_po_2from), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "fixed_to_fixed", VALUEFUNC(_wrap_Bitwise_fixed_to_fixed), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "float_to_fixed", VALUEFUNC(_wrap_Bitwise_float_to_fixed), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "fixed_to_float", VALUEFUNC(_wrap_Bitwise_fixed_to_float), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "int_write", VALUEFUNC(_wrap_Bitwise_int_write), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "int_read", VALUEFUNC(_wrap_Bitwise_int_read), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "float_to_half", VALUEFUNC(_wrap_Bitwise_float_to_half), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "float_to_half_i", VALUEFUNC(_wrap_Bitwise_float_to_half_i), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "half_to_float", VALUEFUNC(_wrap_Bitwise_half_to_float), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "half_to_float_i", VALUEFUNC(_wrap_Bitwise_half_to_float_i), -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, "create_bone", VALUEFUNC(_wrap_Skeleton_create_bone), -1);
  rb_define_method(SwigClassSkeleton.klass, "get_num_bones", VALUEFUNC(_wrap_Skeleton_get_num_bones), -1);
  rb_define_method(SwigClassSkeleton.klass, "get_root_bone", VALUEFUNC(_wrap_Skeleton_get_root_bone), -1);
  rb_define_method(SwigClassSkeleton.klass, "get_root_bone_iterator", VALUEFUNC(_wrap_Skeleton_get_root_bone_iterator), -1);
  rb_define_method(SwigClassSkeleton.klass, "get_bone_iterator", VALUEFUNC(_wrap_Skeleton_get_bone_iterator), -1);
  rb_define_method(SwigClassSkeleton.klass, "get_bone", VALUEFUNC(_wrap_Skeleton_get_bone), -1);
  rb_define_method(SwigClassSkeleton.klass, "has_bone", VALUEFUNC(_wrap_Skeleton_has_bone), -1);
  rb_define_method(SwigClassSkeleton.klass, "set_binding_pose", VALUEFUNC(_wrap_Skeleton_set_binding_pose), -1);
  rb_define_method(SwigClassSkeleton.klass, "reset", VALUEFUNC(_wrap_Skeleton_reset), -1);
  rb_define_method(SwigClassSkeleton.klass, "create_animation", VALUEFUNC(_wrap_Skeleton_create_animation), -1);
  rb_define_method(SwigClassSkeleton.klass, "_get_animation_impl", VALUEFUNC(_wrap_Skeleton__get_animation_impl), -1);
  rb_define_method(SwigClassSkeleton.klass, "has_animation", VALUEFUNC(_wrap_Skeleton_has_animation), -1);
  rb_define_method(SwigClassSkeleton.klass, "remove_animation", VALUEFUNC(_wrap_Skeleton_remove_animation), -1);
  rb_define_method(SwigClassSkeleton.klass, "set_animation_state", VALUEFUNC(_wrap_Skeleton_set_animation_state), -1);
  rb_define_method(SwigClassSkeleton.klass, "_init_animation_state", VALUEFUNC(_wrap_Skeleton__init_animation_state), -1);
  rb_define_method(SwigClassSkeleton.klass, "_refresh_animation_state", VALUEFUNC(_wrap_Skeleton__refresh_animation_state), -1);
  rb_define_method(SwigClassSkeleton.klass, "_get_bone_matrices", VALUEFUNC(_wrap_Skeleton__get_bone_matrices), -1);
  rb_define_method(SwigClassSkeleton.klass, "get_num_animations", VALUEFUNC(_wrap_Skeleton_get_num_animations), -1);
  rb_define_method(SwigClassSkeleton.klass, "get_animation", VALUEFUNC(_wrap_Skeleton_get_animation), -1);
  rb_define_method(SwigClassSkeleton.klass, "get_blend_mode", VALUEFUNC(_wrap_Skeleton_get_blend_mode), -1);
  rb_define_method(SwigClassSkeleton.klass, "set_blend_mode", VALUEFUNC(_wrap_Skeleton_set_blend_mode), -1);
  rb_define_method(SwigClassSkeleton.klass, "_update_transforms", VALUEFUNC(_wrap_Skeleton__update_transforms), -1);
  rb_define_method(SwigClassSkeleton.klass, "optimise_all_animations", VALUEFUNC(_wrap_Skeleton_optimise_all_animations), -1);
  rb_define_method(SwigClassSkeleton.klass, "add_linked_skeleton_animation_source", VALUEFUNC(_wrap_Skeleton_add_linked_skeleton_animation_source), -1);
  rb_define_method(SwigClassSkeleton.klass, "remove_all_linked_skeleton_animation_sources", VALUEFUNC(_wrap_Skeleton_remove_all_linked_skeleton_animation_sources), -1);
  rb_define_method(SwigClassSkeleton.klass, "get_linked_skeleton_animation_source_iterator", VALUEFUNC(_wrap_Skeleton_get_linked_skeleton_animation_source_iterator), -1);
  rb_define_method(SwigClassSkeleton.klass, "_notify_manual_bones_dirty", VALUEFUNC(_wrap_Skeleton__notify_manual_bones_dirty), -1);
  rb_define_method(SwigClassSkeleton.klass, "_notify_manual_bone_state_change", VALUEFUNC(_wrap_Skeleton__notify_manual_bone_state_change), -1);
  rb_define_method(SwigClassSkeleton.klass, "get_manual_bones_dirty", VALUEFUNC(_wrap_Skeleton_get_manual_bones_dirty), -1);
  rb_define_method(SwigClassSkeleton.klass, "has_manual_bones", VALUEFUNC(_wrap_Skeleton_has_manual_bones), -1);
  rb_define_method(SwigClassSkeleton.klass, "_merge_skeleton_animations", VALUEFUNC(_wrap_Skeleton__merge_skeleton_animations), -1);
  rb_define_method(SwigClassSkeleton.klass, "_build_map_bone_by_handle", VALUEFUNC(_wrap_Skeleton__build_map_bone_by_handle), -1);
  rb_define_method(SwigClassSkeleton.klass, "_build_map_bone_by_name", VALUEFUNC(_wrap_Skeleton__build_map_bone_by_name), -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, "use_count", VALUEFUNC(_wrap_MeshSharedPtr_use_count), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "use_count_pointer", VALUEFUNC(_wrap_MeshSharedPtr_use_count_pointer), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_pointer", VALUEFUNC(_wrap_MeshSharedPtr_get_pointer), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "free_method", VALUEFUNC(_wrap_MeshSharedPtr_free_method), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "is_null", VALUEFUNC(_wrap_MeshSharedPtr_is_null), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "set_null", VALUEFUNC(_wrap_MeshSharedPtr_set_null), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "create_sub_mesh", VALUEFUNC(_wrap_MeshSharedPtr_create_sub_mesh), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "name_sub_mesh", VALUEFUNC(_wrap_MeshSharedPtr_name_sub_mesh), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "unname_sub_mesh", VALUEFUNC(_wrap_MeshSharedPtr_unname_sub_mesh), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_get_sub_mesh_index", VALUEFUNC(_wrap_MeshSharedPtr__get_sub_mesh_index), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_num_sub_meshes", VALUEFUNC(_wrap_MeshSharedPtr_get_num_sub_meshes), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_sub_mesh", VALUEFUNC(_wrap_MeshSharedPtr_get_sub_mesh), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "destroy_sub_mesh", VALUEFUNC(_wrap_MeshSharedPtr_destroy_sub_mesh), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_sub_mesh_iterator", VALUEFUNC(_wrap_MeshSharedPtr_get_sub_mesh_iterator), -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, "get_bounds", VALUEFUNC(_wrap_MeshSharedPtr_get_bounds), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_bounding_sphere_radius", VALUEFUNC(_wrap_MeshSharedPtr_get_bounding_sphere_radius), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_set_bounds", VALUEFUNC(_wrap_MeshSharedPtr__set_bounds), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_set_bounding_sphere_radius", VALUEFUNC(_wrap_MeshSharedPtr__set_bounding_sphere_radius), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "set_skeleton_name", VALUEFUNC(_wrap_MeshSharedPtr_set_skeleton_name), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "has_skeleton", VALUEFUNC(_wrap_MeshSharedPtr_has_skeleton), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "has_vertex_animation", VALUEFUNC(_wrap_MeshSharedPtr_has_vertex_animation), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_skeleton", VALUEFUNC(_wrap_MeshSharedPtr_get_skeleton), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_skeleton_name", VALUEFUNC(_wrap_MeshSharedPtr_get_skeleton_name), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_init_animation_state", VALUEFUNC(_wrap_MeshSharedPtr__init_animation_state), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_refresh_animation_state", VALUEFUNC(_wrap_MeshSharedPtr__refresh_animation_state), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "add_bone_assignment", VALUEFUNC(_wrap_MeshSharedPtr_add_bone_assignment), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "clear_bone_assignments", VALUEFUNC(_wrap_MeshSharedPtr_clear_bone_assignments), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_notify_skeleton", VALUEFUNC(_wrap_MeshSharedPtr__notify_skeleton), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_bone_assignment_iterator", VALUEFUNC(_wrap_MeshSharedPtr_get_bone_assignment_iterator), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_bone_assignments", VALUEFUNC(_wrap_MeshSharedPtr_get_bone_assignments), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_num_lod_levels", VALUEFUNC(_wrap_MeshSharedPtr_get_num_lod_levels), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_lod_level", VALUEFUNC(_wrap_MeshSharedPtr_get_lod_level), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "create_manual_lod_level", VALUEFUNC(_wrap_MeshSharedPtr_create_manual_lod_level), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "update_manual_lod_level", VALUEFUNC(_wrap_MeshSharedPtr_update_manual_lod_level), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_lod_index", VALUEFUNC(_wrap_MeshSharedPtr_get_lod_index), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "is_lod_manual", VALUEFUNC(_wrap_MeshSharedPtr_is_lod_manual), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_set_lod_info", VALUEFUNC(_wrap_MeshSharedPtr__set_lod_info), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_set_lod_usage", VALUEFUNC(_wrap_MeshSharedPtr__set_lod_usage), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_set_sub_mesh_lod_face_list", VALUEFUNC(_wrap_MeshSharedPtr__set_sub_mesh_lod_face_list), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "remove_lod_levels", VALUEFUNC(_wrap_MeshSharedPtr_remove_lod_levels), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "set_vertex_buffer_policy", VALUEFUNC(_wrap_MeshSharedPtr_set_vertex_buffer_policy), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "set_index_buffer_policy", VALUEFUNC(_wrap_MeshSharedPtr_set_index_buffer_policy), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_vertex_buffer_usage", VALUEFUNC(_wrap_MeshSharedPtr_get_vertex_buffer_usage), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_index_buffer_usage", VALUEFUNC(_wrap_MeshSharedPtr_get_index_buffer_usage), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "is_vertex_buffer_shadowed", VALUEFUNC(_wrap_MeshSharedPtr_is_vertex_buffer_shadowed), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "is_index_buffer_shadowed", VALUEFUNC(_wrap_MeshSharedPtr_is_index_buffer_shadowed), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_rationalise_bone_assignments", VALUEFUNC(_wrap_MeshSharedPtr__rationalise_bone_assignments), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_compile_bone_assignments", VALUEFUNC(_wrap_MeshSharedPtr__compile_bone_assignments), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_update_compiled_bone_assignments", VALUEFUNC(_wrap_MeshSharedPtr__update_compiled_bone_assignments), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "build_tangent_vectors", VALUEFUNC(_wrap_MeshSharedPtr_build_tangent_vectors), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "suggest_tangent_vector_build_params", VALUEFUNC(_wrap_MeshSharedPtr_suggest_tangent_vector_build_params), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "build_edge_list", VALUEFUNC(_wrap_MeshSharedPtr_build_edge_list), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "free_edge_list", VALUEFUNC(_wrap_MeshSharedPtr_free_edge_list), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "prepare_for_shadow_volume", VALUEFUNC(_wrap_MeshSharedPtr_prepare_for_shadow_volume), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_edge_list", VALUEFUNC(_wrap_MeshSharedPtr_get_edge_list), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "is_prepared_for_shadow_volumes", VALUEFUNC(_wrap_MeshSharedPtr_is_prepared_for_shadow_volumes), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "is_edge_list_built", VALUEFUNC(_wrap_MeshSharedPtr_is_edge_list_built), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "prepare_matrices_for_vertex_blend", VALUEFUNC(_wrap_MeshSharedPtr_prepare_matrices_for_vertex_blend), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "software_vertex_blend", VALUEFUNC(_wrap_MeshSharedPtr_software_vertex_blend), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "software_vertex_morph", VALUEFUNC(_wrap_MeshSharedPtr_software_vertex_morph), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "software_vertex_pose_blend", VALUEFUNC(_wrap_MeshSharedPtr_software_vertex_pose_blend), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_sub_mesh_name_map", VALUEFUNC(_wrap_MeshSharedPtr_get_sub_mesh_name_map), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "set_auto_build_edge_lists", VALUEFUNC(_wrap_MeshSharedPtr_set_auto_build_edge_lists), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_auto_build_edge_lists", VALUEFUNC(_wrap_MeshSharedPtr_get_auto_build_edge_lists), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_shared_vertex_data_animation_type", VALUEFUNC(_wrap_MeshSharedPtr_get_shared_vertex_data_animation_type), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_shared_vertex_data_animation_includes_normals", VALUEFUNC(_wrap_MeshSharedPtr_get_shared_vertex_data_animation_includes_normals), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "create_animation", VALUEFUNC(_wrap_MeshSharedPtr_create_animation), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_animation", VALUEFUNC(_wrap_MeshSharedPtr_get_animation), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_get_animation_impl", VALUEFUNC(_wrap_MeshSharedPtr__get_animation_impl), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "has_animation", VALUEFUNC(_wrap_MeshSharedPtr_has_animation), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "remove_animation", VALUEFUNC(_wrap_MeshSharedPtr_remove_animation), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_num_animations", VALUEFUNC(_wrap_MeshSharedPtr_get_num_animations), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "remove_all_animations", VALUEFUNC(_wrap_MeshSharedPtr_remove_all_animations), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_vertex_data_by_track_handle", VALUEFUNC(_wrap_MeshSharedPtr_get_vertex_data_by_track_handle), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "update_material_for_all_sub_meshes", VALUEFUNC(_wrap_MeshSharedPtr_update_material_for_all_sub_meshes), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_determine_animation_types", VALUEFUNC(_wrap_MeshSharedPtr__determine_animation_types), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_get_animation_types_dirty", VALUEFUNC(_wrap_MeshSharedPtr__get_animation_types_dirty), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "create_pose", VALUEFUNC(_wrap_MeshSharedPtr_create_pose), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_pose_count", VALUEFUNC(_wrap_MeshSharedPtr_get_pose_count), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_pose", VALUEFUNC(_wrap_MeshSharedPtr_get_pose), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "remove_pose", VALUEFUNC(_wrap_MeshSharedPtr_remove_pose), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "remove_all_poses", VALUEFUNC(_wrap_MeshSharedPtr_remove_all_poses), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_pose_list", VALUEFUNC(_wrap_MeshSharedPtr_get_pose_list), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_lod_strategy", VALUEFUNC(_wrap_MeshSharedPtr_get_lod_strategy), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "set_lod_strategy", VALUEFUNC(_wrap_MeshSharedPtr_set_lod_strategy), -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, "is_reloadable", VALUEFUNC(_wrap_MeshSharedPtr_is_reloadable), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "is_manually_loaded", VALUEFUNC(_wrap_MeshSharedPtr_is_manually_loaded), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "unload", VALUEFUNC(_wrap_MeshSharedPtr_unload), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_size", VALUEFUNC(_wrap_MeshSharedPtr_get_size), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "touch", VALUEFUNC(_wrap_MeshSharedPtr_touch), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_name", VALUEFUNC(_wrap_MeshSharedPtr_get_name), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_handle", VALUEFUNC(_wrap_MeshSharedPtr_get_handle), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "is_prepared", VALUEFUNC(_wrap_MeshSharedPtr_is_prepared), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "is_loaded", VALUEFUNC(_wrap_MeshSharedPtr_is_loaded), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "is_loading", VALUEFUNC(_wrap_MeshSharedPtr_is_loading), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_loading_state", VALUEFUNC(_wrap_MeshSharedPtr_get_loading_state), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "is_background_loaded", VALUEFUNC(_wrap_MeshSharedPtr_is_background_loaded), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "set_background_loaded", VALUEFUNC(_wrap_MeshSharedPtr_set_background_loaded), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "escalate_loading", VALUEFUNC(_wrap_MeshSharedPtr_escalate_loading), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "add_listener", VALUEFUNC(_wrap_MeshSharedPtr_add_listener), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "remove_listener", VALUEFUNC(_wrap_MeshSharedPtr_remove_listener), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_group", VALUEFUNC(_wrap_MeshSharedPtr_get_group), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "change_group_ownership", VALUEFUNC(_wrap_MeshSharedPtr_change_group_ownership), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_creator", VALUEFUNC(_wrap_MeshSharedPtr_get_creator), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_origin", VALUEFUNC(_wrap_MeshSharedPtr_get_origin), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_notify_origin", VALUEFUNC(_wrap_MeshSharedPtr__notify_origin), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_state_count", VALUEFUNC(_wrap_MeshSharedPtr_get_state_count), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_dirty_state", VALUEFUNC(_wrap_MeshSharedPtr__dirty_state), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_fire_loading_complete", VALUEFUNC(_wrap_MeshSharedPtr__fire_loading_complete), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_fire_preparing_complete", VALUEFUNC(_wrap_MeshSharedPtr__fire_preparing_complete), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_fire_unloading_complete", VALUEFUNC(_wrap_MeshSharedPtr__fire_unloading_complete), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_param_dictionary", VALUEFUNC(_wrap_MeshSharedPtr_get_param_dictionary), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_parameters", VALUEFUNC(_wrap_MeshSharedPtr_get_parameters), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "set_parameter", VALUEFUNC(_wrap_MeshSharedPtr_set_parameter), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "set_parameter_list", VALUEFUNC(_wrap_MeshSharedPtr_set_parameter_list), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get_parameter", VALUEFUNC(_wrap_MeshSharedPtr_get_parameter), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "copy_parameters_to", VALUEFUNC(_wrap_MeshSharedPtr_copy_parameters_to), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "cleanup_dictionary", VALUEFUNC(_wrap_MeshSharedPtr_cleanup_dictionary), -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, "create_sub_mesh", VALUEFUNC(_wrap_Mesh_create_sub_mesh), -1);
  rb_define_method(SwigClassMesh.klass, "name_sub_mesh", VALUEFUNC(_wrap_Mesh_name_sub_mesh), -1);
  rb_define_method(SwigClassMesh.klass, "unname_sub_mesh", VALUEFUNC(_wrap_Mesh_unname_sub_mesh), -1);
  rb_define_method(SwigClassMesh.klass, "_get_sub_mesh_index", VALUEFUNC(_wrap_Mesh__get_sub_mesh_index), -1);
  rb_define_method(SwigClassMesh.klass, "get_num_sub_meshes", VALUEFUNC(_wrap_Mesh_get_num_sub_meshes), -1);
  rb_define_method(SwigClassMesh.klass, "get_sub_mesh", VALUEFUNC(_wrap_Mesh_get_sub_mesh), -1);
  rb_define_method(SwigClassMesh.klass, "destroy_sub_mesh", VALUEFUNC(_wrap_Mesh_destroy_sub_mesh), -1);
  rb_define_method(SwigClassMesh.klass, "get_sub_mesh_iterator", VALUEFUNC(_wrap_Mesh_get_sub_mesh_iterator), -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, "get_bounds", VALUEFUNC(_wrap_Mesh_get_bounds), -1);
  rb_define_method(SwigClassMesh.klass, "get_bounding_sphere_radius", VALUEFUNC(_wrap_Mesh_get_bounding_sphere_radius), -1);
  rb_define_method(SwigClassMesh.klass, "_set_bounds", VALUEFUNC(_wrap_Mesh__set_bounds), -1);
  rb_define_method(SwigClassMesh.klass, "_set_bounding_sphere_radius", VALUEFUNC(_wrap_Mesh__set_bounding_sphere_radius), -1);
  rb_define_method(SwigClassMesh.klass, "set_skeleton_name", VALUEFUNC(_wrap_Mesh_set_skeleton_name), -1);
  rb_define_method(SwigClassMesh.klass, "has_skeleton", VALUEFUNC(_wrap_Mesh_has_skeleton), -1);
  rb_define_method(SwigClassMesh.klass, "has_vertex_animation", VALUEFUNC(_wrap_Mesh_has_vertex_animation), -1);
  rb_define_method(SwigClassMesh.klass, "get_skeleton", VALUEFUNC(_wrap_Mesh_get_skeleton), -1);
  rb_define_method(SwigClassMesh.klass, "get_skeleton_name", VALUEFUNC(_wrap_Mesh_get_skeleton_name), -1);
  rb_define_method(SwigClassMesh.klass, "_init_animation_state", VALUEFUNC(_wrap_Mesh__init_animation_state), -1);
  rb_define_method(SwigClassMesh.klass, "_refresh_animation_state", VALUEFUNC(_wrap_Mesh__refresh_animation_state), -1);
  rb_define_method(SwigClassMesh.klass, "add_bone_assignment", VALUEFUNC(_wrap_Mesh_add_bone_assignment), -1);
  rb_define_method(SwigClassMesh.klass, "clear_bone_assignments", VALUEFUNC(_wrap_Mesh_clear_bone_assignments), -1);
  rb_define_method(SwigClassMesh.klass, "_notify_skeleton", VALUEFUNC(_wrap_Mesh__notify_skeleton), -1);
  rb_define_method(SwigClassMesh.klass, "get_bone_assignment_iterator", VALUEFUNC(_wrap_Mesh_get_bone_assignment_iterator), -1);
  rb_define_method(SwigClassMesh.klass, "get_bone_assignments", VALUEFUNC(_wrap_Mesh_get_bone_assignments), -1);
  rb_define_method(SwigClassMesh.klass, "get_num_lod_levels", VALUEFUNC(_wrap_Mesh_get_num_lod_levels), -1);
  rb_define_method(SwigClassMesh.klass, "get_lod_level", VALUEFUNC(_wrap_Mesh_get_lod_level), -1);
  rb_define_method(SwigClassMesh.klass, "create_manual_lod_level", VALUEFUNC(_wrap_Mesh_create_manual_lod_level), -1);
  rb_define_method(SwigClassMesh.klass, "update_manual_lod_level", VALUEFUNC(_wrap_Mesh_update_manual_lod_level), -1);
  rb_define_method(SwigClassMesh.klass, "get_lod_index", VALUEFUNC(_wrap_Mesh_get_lod_index), -1);
  rb_define_method(SwigClassMesh.klass, "is_lod_manual", VALUEFUNC(_wrap_Mesh_is_lod_manual), -1);
  rb_define_method(SwigClassMesh.klass, "_set_lod_info", VALUEFUNC(_wrap_Mesh__set_lod_info), -1);
  rb_define_method(SwigClassMesh.klass, "_set_lod_usage", VALUEFUNC(_wrap_Mesh__set_lod_usage), -1);
  rb_define_method(SwigClassMesh.klass, "_set_sub_mesh_lod_face_list", VALUEFUNC(_wrap_Mesh__set_sub_mesh_lod_face_list), -1);
  rb_define_method(SwigClassMesh.klass, "remove_lod_levels", VALUEFUNC(_wrap_Mesh_remove_lod_levels), -1);
  rb_define_method(SwigClassMesh.klass, "set_vertex_buffer_policy", VALUEFUNC(_wrap_Mesh_set_vertex_buffer_policy), -1);
  rb_define_method(SwigClassMesh.klass, "set_index_buffer_policy", VALUEFUNC(_wrap_Mesh_set_index_buffer_policy), -1);
  rb_define_method(SwigClassMesh.klass, "get_vertex_buffer_usage", VALUEFUNC(_wrap_Mesh_get_vertex_buffer_usage), -1);
  rb_define_method(SwigClassMesh.klass, "get_index_buffer_usage", VALUEFUNC(_wrap_Mesh_get_index_buffer_usage), -1);
  rb_define_method(SwigClassMesh.klass, "is_vertex_buffer_shadowed", VALUEFUNC(_wrap_Mesh_is_vertex_buffer_shadowed), -1);
  rb_define_method(SwigClassMesh.klass, "is_index_buffer_shadowed", VALUEFUNC(_wrap_Mesh_is_index_buffer_shadowed), -1);
  rb_define_method(SwigClassMesh.klass, "_rationalise_bone_assignments", VALUEFUNC(_wrap_Mesh__rationalise_bone_assignments), -1);
  rb_define_method(SwigClassMesh.klass, "_compile_bone_assignments", VALUEFUNC(_wrap_Mesh__compile_bone_assignments), -1);
  rb_define_method(SwigClassMesh.klass, "_update_compiled_bone_assignments", VALUEFUNC(_wrap_Mesh__update_compiled_bone_assignments), -1);
  rb_define_method(SwigClassMesh.klass, "build_tangent_vectors", VALUEFUNC(_wrap_Mesh_build_tangent_vectors), -1);
  rb_define_method(SwigClassMesh.klass, "suggest_tangent_vector_build_params", VALUEFUNC(_wrap_Mesh_suggest_tangent_vector_build_params), -1);
  rb_define_method(SwigClassMesh.klass, "build_edge_list", VALUEFUNC(_wrap_Mesh_build_edge_list), -1);
  rb_define_method(SwigClassMesh.klass, "free_edge_list", VALUEFUNC(_wrap_Mesh_free_edge_list), -1);
  rb_define_method(SwigClassMesh.klass, "prepare_for_shadow_volume", VALUEFUNC(_wrap_Mesh_prepare_for_shadow_volume), -1);
  rb_define_method(SwigClassMesh.klass, "get_edge_list", VALUEFUNC(_wrap_Mesh_get_edge_list), -1);
  rb_define_method(SwigClassMesh.klass, "is_prepared_for_shadow_volumes", VALUEFUNC(_wrap_Mesh_is_prepared_for_shadow_volumes), -1);
  rb_define_method(SwigClassMesh.klass, "is_edge_list_built", VALUEFUNC(_wrap_Mesh_is_edge_list_built), -1);
  rb_define_singleton_method(SwigClassMesh.klass, "prepare_matrices_for_vertex_blend", VALUEFUNC(_wrap_Mesh_prepare_matrices_for_vertex_blend), -1);
  rb_define_singleton_method(SwigClassMesh.klass, "software_vertex_blend", VALUEFUNC(_wrap_Mesh_software_vertex_blend), -1);
  rb_define_singleton_method(SwigClassMesh.klass, "software_vertex_morph", VALUEFUNC(_wrap_Mesh_software_vertex_morph), -1);
  rb_define_singleton_method(SwigClassMesh.klass, "software_vertex_pose_blend", VALUEFUNC(_wrap_Mesh_software_vertex_pose_blend), -1);
  rb_define_method(SwigClassMesh.klass, "get_sub_mesh_name_map", VALUEFUNC(_wrap_Mesh_get_sub_mesh_name_map), -1);
  rb_define_method(SwigClassMesh.klass, "set_auto_build_edge_lists", VALUEFUNC(_wrap_Mesh_set_auto_build_edge_lists), -1);
  rb_define_method(SwigClassMesh.klass, "get_auto_build_edge_lists", VALUEFUNC(_wrap_Mesh_get_auto_build_edge_lists), -1);
  rb_define_method(SwigClassMesh.klass, "get_shared_vertex_data_animation_type", VALUEFUNC(_wrap_Mesh_get_shared_vertex_data_animation_type), -1);
  rb_define_method(SwigClassMesh.klass, "get_shared_vertex_data_animation_includes_normals", VALUEFUNC(_wrap_Mesh_get_shared_vertex_data_animation_includes_normals), -1);
  rb_define_method(SwigClassMesh.klass, "create_animation", VALUEFUNC(_wrap_Mesh_create_animation), -1);
  rb_define_method(SwigClassMesh.klass, "_get_animation_impl", VALUEFUNC(_wrap_Mesh__get_animation_impl), -1);
  rb_define_method(SwigClassMesh.klass, "has_animation", VALUEFUNC(_wrap_Mesh_has_animation), -1);
  rb_define_method(SwigClassMesh.klass, "remove_animation", VALUEFUNC(_wrap_Mesh_remove_animation), -1);
  rb_define_method(SwigClassMesh.klass, "get_num_animations", VALUEFUNC(_wrap_Mesh_get_num_animations), -1);
  rb_define_method(SwigClassMesh.klass, "get_animation", VALUEFUNC(_wrap_Mesh_get_animation), -1);
  rb_define_method(SwigClassMesh.klass, "remove_all_animations", VALUEFUNC(_wrap_Mesh_remove_all_animations), -1);
  rb_define_method(SwigClassMesh.klass, "get_vertex_data_by_track_handle", VALUEFUNC(_wrap_Mesh_get_vertex_data_by_track_handle), -1);
  rb_define_method(SwigClassMesh.klass, "update_material_for_all_sub_meshes", VALUEFUNC(_wrap_Mesh_update_material_for_all_sub_meshes), -1);
  rb_define_method(SwigClassMesh.klass, "_determine_animation_types", VALUEFUNC(_wrap_Mesh__determine_animation_types), -1);
  rb_define_method(SwigClassMesh.klass, "_get_animation_types_dirty", VALUEFUNC(_wrap_Mesh__get_animation_types_dirty), -1);
  rb_define_method(SwigClassMesh.klass, "create_pose", VALUEFUNC(_wrap_Mesh_create_pose), -1);
  rb_define_method(SwigClassMesh.klass, "get_pose_count", VALUEFUNC(_wrap_Mesh_get_pose_count), -1);
  rb_define_method(SwigClassMesh.klass, "get_pose", VALUEFUNC(_wrap_Mesh_get_pose), -1);
  rb_define_method(SwigClassMesh.klass, "remove_pose", VALUEFUNC(_wrap_Mesh_remove_pose), -1);
  rb_define_method(SwigClassMesh.klass, "remove_all_poses", VALUEFUNC(_wrap_Mesh_remove_all_poses), -1);
  rb_define_method(SwigClassMesh.klass, "get_pose_list", VALUEFUNC(_wrap_Mesh_get_pose_list), -1);
  rb_define_method(SwigClassMesh.klass, "get_lod_strategy", VALUEFUNC(_wrap_Mesh_get_lod_strategy), -1);
  rb_define_method(SwigClassMesh.klass, "set_lod_strategy", VALUEFUNC(_wrap_Mesh_set_lod_strategy), -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, "get_name", VALUEFUNC(_wrap_Node_get_name), -1);
  rb_define_method(SwigClassNode.klass, "get_parent", VALUEFUNC(_wrap_Node_get_parent), -1);
  rb_define_method(SwigClassNode.klass, "get_orientation", VALUEFUNC(_wrap_Node_get_orientation), -1);
  rb_define_method(SwigClassNode.klass, "set_orientation", VALUEFUNC(_wrap_Node_set_orientation), -1);
  rb_define_method(SwigClassNode.klass, "reset_orientation", VALUEFUNC(_wrap_Node_reset_orientation), -1);
  rb_define_method(SwigClassNode.klass, "set_position", VALUEFUNC(_wrap_Node_set_position), -1);
  rb_define_method(SwigClassNode.klass, "get_position", VALUEFUNC(_wrap_Node_get_position), -1);
  rb_define_method(SwigClassNode.klass, "set_scale", VALUEFUNC(_wrap_Node_set_scale), -1);
  rb_define_method(SwigClassNode.klass, "get_scale", VALUEFUNC(_wrap_Node_get_scale), -1);
  rb_define_method(SwigClassNode.klass, "set_inherit_orientation", VALUEFUNC(_wrap_Node_set_inherit_orientation), -1);
  rb_define_method(SwigClassNode.klass, "get_inherit_orientation", VALUEFUNC(_wrap_Node_get_inherit_orientation), -1);
  rb_define_method(SwigClassNode.klass, "set_inherit_scale", VALUEFUNC(_wrap_Node_set_inherit_scale), -1);
  rb_define_method(SwigClassNode.klass, "get_inherit_scale", VALUEFUNC(_wrap_Node_get_inherit_scale), -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, "get_local_axes", VALUEFUNC(_wrap_Node_get_local_axes), -1);
  rb_define_method(SwigClassNode.klass, "create_child", VALUEFUNC(_wrap_Node_create_child), -1);
  rb_define_method(SwigClassNode.klass, "add_child", VALUEFUNC(_wrap_Node_add_child), -1);
  rb_define_method(SwigClassNode.klass, "num_children", VALUEFUNC(_wrap_Node_num_children), -1);
  rb_define_method(SwigClassNode.klass, "get_child", VALUEFUNC(_wrap_Node_get_child), -1);
  rb_define_method(SwigClassNode.klass, "remove_child", VALUEFUNC(_wrap_Node_remove_child), -1);
  rb_define_method(SwigClassNode.klass, "remove_all_children", VALUEFUNC(_wrap_Node_remove_all_children), -1);
  rb_define_method(SwigClassNode.klass, "_set_derived_position", VALUEFUNC(_wrap_Node__set_derived_position), -1);
  rb_define_method(SwigClassNode.klass, "_set_derived_orientation", VALUEFUNC(_wrap_Node__set_derived_orientation), -1);
  rb_define_method(SwigClassNode.klass, "_get_derived_orientation", VALUEFUNC(_wrap_Node__get_derived_orientation), -1);
  rb_define_method(SwigClassNode.klass, "_get_derived_position", VALUEFUNC(_wrap_Node__get_derived_position), -1);
  rb_define_method(SwigClassNode.klass, "_get_derived_scale", VALUEFUNC(_wrap_Node__get_derived_scale), -1);
  rb_define_method(SwigClassNode.klass, "_get_full_transform", VALUEFUNC(_wrap_Node__get_full_transform), -1);
  rb_define_method(SwigClassNode.klass, "_update", VALUEFUNC(_wrap_Node__update), -1);
  rb_define_method(SwigClassNode.klass, "set_listener", VALUEFUNC(_wrap_Node_set_listener), -1);
  rb_define_method(SwigClassNode.klass, "get_listener", VALUEFUNC(_wrap_Node_get_listener), -1);
  rb_define_method(SwigClassNode.klass, "set_initial_state", VALUEFUNC(_wrap_Node_set_initial_state), -1);
  rb_define_method(SwigClassNode.klass, "reset_to_initial_state", VALUEFUNC(_wrap_Node_reset_to_initial_state), -1);
  rb_define_method(SwigClassNode.klass, "get_initial_position", VALUEFUNC(_wrap_Node_get_initial_position), -1);
  rb_define_method(SwigClassNode.klass, "convert_world_to_local_position", VALUEFUNC(_wrap_Node_convert_world_to_local_position), -1);
  rb_define_method(SwigClassNode.klass, "convert_local_to_world_position", VALUEFUNC(_wrap_Node_convert_local_to_world_position), -1);
  rb_define_method(SwigClassNode.klass, "convert_world_to_local_orientation", VALUEFUNC(_wrap_Node_convert_world_to_local_orientation), -1);
  rb_define_method(SwigClassNode.klass, "convert_local_to_world_orientation", VALUEFUNC(_wrap_Node_convert_local_to_world_orientation), -1);
  rb_define_method(SwigClassNode.klass, "get_initial_orientation", VALUEFUNC(_wrap_Node_get_initial_orientation), -1);
  rb_define_method(SwigClassNode.klass, "get_initial_scale", VALUEFUNC(_wrap_Node_get_initial_scale), -1);
  rb_define_method(SwigClassNode.klass, "get_squared_view_depth", VALUEFUNC(_wrap_Node_get_squared_view_depth), -1);
  rb_define_method(SwigClassNode.klass, "need_update", VALUEFUNC(_wrap_Node_need_update), -1);
  rb_define_method(SwigClassNode.klass, "request_update", VALUEFUNC(_wrap_Node_request_update), -1);
  rb_define_method(SwigClassNode.klass, "cancel_update", VALUEFUNC(_wrap_Node_cancel_update), -1);
  rb_define_method(SwigClassNode.klass, "get_debug_renderable", VALUEFUNC(_wrap_Node_get_debug_renderable), -1);
  rb_define_singleton_method(SwigClassNode.klass, "queue_need_update", VALUEFUNC(_wrap_Node_queue_need_update), -1);
  rb_define_singleton_method(SwigClassNode.klass, "process_queued_updates", VALUEFUNC(_wrap_Node_process_queued_updates), -1);
  rb_define_method(SwigClassNode.klass, "set_user_any", VALUEFUNC(_wrap_Node_set_user_any), -1);
  rb_define_method(SwigClassNode.klass, "get_user_any", VALUEFUNC(_wrap_Node_get_user_any), -1);
  rb_define_method(SwigClassNode.klass, "get_user_object_bindings", VALUEFUNC(_wrap_Node_get_user_object_bindings), -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, "create_child", VALUEFUNC(_wrap_Bone_create_child), -1);
  rb_define_method(SwigClassBone.klass, "get_handle", VALUEFUNC(_wrap_Bone_get_handle), -1);
  rb_define_method(SwigClassBone.klass, "set_binding_pose", VALUEFUNC(_wrap_Bone_set_binding_pose), -1);
  rb_define_method(SwigClassBone.klass, "reset", VALUEFUNC(_wrap_Bone_reset), -1);
  rb_define_method(SwigClassBone.klass, "set_manually_controlled", VALUEFUNC(_wrap_Bone_set_manually_controlled), -1);
  rb_define_method(SwigClassBone.klass, "is_manually_controlled", VALUEFUNC(_wrap_Bone_is_manually_controlled), -1);
  rb_define_method(SwigClassBone.klass, "_get_offset_transform", VALUEFUNC(_wrap_Bone__get_offset_transform), -1);
  rb_define_method(SwigClassBone.klass, "_get_binding_pose_inverse_scale", VALUEFUNC(_wrap_Bone__get_binding_pose_inverse_scale), -1);
  rb_define_method(SwigClassBone.klass, "_get_binding_pose_inverse_position", VALUEFUNC(_wrap_Bone__get_binding_pose_inverse_position), -1);
  rb_define_method(SwigClassBone.klass, "_get_binding_pose_inverse_orientation", VALUEFUNC(_wrap_Bone__get_binding_pose_inverse_orientation), -1);
  rb_define_method(SwigClassBone.klass, "need_update", VALUEFUNC(_wrap_Bone_need_update), -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, "in_string", VALUEFUNC(_wrap_UTFString_in_string), -1);
  rb_define_method(SwigClassUTFString.klass, "as_utf8", VALUEFUNC(_wrap_UTFString_as_utf8), -1);
  rb_define_method(SwigClassUTFString.klass, "as_utf_8_c_str", VALUEFUNC(_wrap_UTFString_as_utf_8_c_str), -1);
  rb_define_method(SwigClassUTFString.klass, "as_utf_32", VALUEFUNC(_wrap_UTFString_as_utf_32), -1);
  rb_define_method(SwigClassUTFString.klass, "as_utf_32_c_str", VALUEFUNC(_wrap_UTFString_as_utf_32_c_str), -1);
  rb_define_method(SwigClassUTFString.klass, "as_wstr", VALUEFUNC(_wrap_UTFString_as_wstr), -1);
  rb_define_method(SwigClassUTFString.klass, "as_wstr_c_str", VALUEFUNC(_wrap_UTFString_as_wstr_c_str), -1);
  rb_define_method(SwigClassUTFString.klass, "at", VALUEFUNC(_wrap_UTFString_at), -1);
  rb_define_method(SwigClassUTFString.klass, "get_char", VALUEFUNC(_wrap_UTFString_get_char), -1);
  rb_define_method(SwigClassUTFString.klass, "set_char", VALUEFUNC(_wrap_UTFString_set_char), -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, "_utf_16_independent_char", VALUEFUNC(_wrap_UTFString__utf_16_independent_char), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf_16_surrogate_lead", VALUEFUNC(_wrap_UTFString__utf_16_surrogate_lead), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf_16_surrogate_follow", VALUEFUNC(_wrap_UTFString__utf_16_surrogate_follow), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf_16_char_length", VALUEFUNC(_wrap_UTFString__utf_16_char_length), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf_16_to_utf_32", VALUEFUNC(_wrap_UTFString__utf_16_to_utf_32), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf_32_to_utf_16", VALUEFUNC(_wrap_UTFString__utf_32_to_utf_16), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf_8_start_char", VALUEFUNC(_wrap_UTFString__utf_8_start_char), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf_8_char_length", VALUEFUNC(_wrap_UTFString__utf_8_char_length), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf_8_to_utf_32", VALUEFUNC(_wrap_UTFString__utf_8_to_utf_32), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf_32_to_utf8", VALUEFUNC(_wrap_UTFString__utf_32_to_utf8), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_verify_utf8", VALUEFUNC(_wrap_UTFString__verify_utf8), -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, "do_get", VALUEFUNC(_wrap_CmdLeft_do_get), -1);
  rb_define_method(SwigClassCmdLeft.klass, "do_set", VALUEFUNC(_wrap_CmdLeft_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdTop_do_get), -1);
  rb_define_method(SwigClassCmdTop.klass, "do_set", VALUEFUNC(_wrap_CmdTop_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdWidth_do_get), -1);
  rb_define_method(SwigClassCmdWidth.klass, "do_set", VALUEFUNC(_wrap_CmdWidth_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdHeight_do_get), -1);
  rb_define_method(SwigClassCmdHeight.klass, "do_set", VALUEFUNC(_wrap_CmdHeight_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdMaterial_do_get), -1);
  rb_define_method(SwigClassCmdMaterial.klass, "do_set", VALUEFUNC(_wrap_CmdMaterial_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdCaption_do_get), -1);
  rb_define_method(SwigClassCmdCaption.klass, "do_set", VALUEFUNC(_wrap_CmdCaption_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdMetricsMode_do_get), -1);
  rb_define_method(SwigClassCmdMetricsMode.klass, "do_set", VALUEFUNC(_wrap_CmdMetricsMode_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdHorizontalAlign_do_get), -1);
  rb_define_method(SwigClassCmdHorizontalAlign.klass, "do_set", VALUEFUNC(_wrap_CmdHorizontalAlign_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdVerticalAlign_do_get), -1);
  rb_define_method(SwigClassCmdVerticalAlign.klass, "do_set", VALUEFUNC(_wrap_CmdVerticalAlign_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdVisible_do_get), -1);
  rb_define_method(SwigClassCmdVisible.klass, "do_set", VALUEFUNC(_wrap_CmdVisible_do_set), -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, "get_name", VALUEFUNC(_wrap_OverlayElement_get_name), -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, "is_visible", VALUEFUNC(_wrap_OverlayElement_is_visible), -1);
  rb_define_method(SwigClassOverlayElement.klass, "is_enabled", VALUEFUNC(_wrap_OverlayElement_is_enabled), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_enabled", VALUEFUNC(_wrap_OverlayElement_set_enabled), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_dimensions", VALUEFUNC(_wrap_OverlayElement_set_dimensions), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_position", VALUEFUNC(_wrap_OverlayElement_set_position), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_width", VALUEFUNC(_wrap_OverlayElement_set_width), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_width", VALUEFUNC(_wrap_OverlayElement_get_width), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_height", VALUEFUNC(_wrap_OverlayElement_set_height), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_height", VALUEFUNC(_wrap_OverlayElement_get_height), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_left", VALUEFUNC(_wrap_OverlayElement_set_left), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_left", VALUEFUNC(_wrap_OverlayElement_get_left), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_top", VALUEFUNC(_wrap_OverlayElement_set_top), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_top", VALUEFUNC(_wrap_OverlayElement_get_top), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_get_left", VALUEFUNC(_wrap_OverlayElement__get_left), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_get_top", VALUEFUNC(_wrap_OverlayElement__get_top), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_get_width", VALUEFUNC(_wrap_OverlayElement__get_width), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_get_height", VALUEFUNC(_wrap_OverlayElement__get_height), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_set_left", VALUEFUNC(_wrap_OverlayElement__set_left), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_set_top", VALUEFUNC(_wrap_OverlayElement__set_top), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_set_width", VALUEFUNC(_wrap_OverlayElement__set_width), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_set_height", VALUEFUNC(_wrap_OverlayElement__set_height), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_set_position", VALUEFUNC(_wrap_OverlayElement__set_position), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_set_dimensions", VALUEFUNC(_wrap_OverlayElement__set_dimensions), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_material_name", VALUEFUNC(_wrap_OverlayElement_get_material_name), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_material_name", VALUEFUNC(_wrap_OverlayElement_set_material_name), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_material", VALUEFUNC(_wrap_OverlayElement_get_material), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_world_transforms", VALUEFUNC(_wrap_OverlayElement_get_world_transforms), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_positions_out_of_date", VALUEFUNC(_wrap_OverlayElement__positions_out_of_date), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_update", VALUEFUNC(_wrap_OverlayElement__update), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_update_from_parent", VALUEFUNC(_wrap_OverlayElement__update_from_parent), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_notify_parent", VALUEFUNC(_wrap_OverlayElement__notify_parent), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_get_derived_left", VALUEFUNC(_wrap_OverlayElement__get_derived_left), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_get_derived_top", VALUEFUNC(_wrap_OverlayElement__get_derived_top), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_get_relative_width", VALUEFUNC(_wrap_OverlayElement__get_relative_width), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_get_relative_height", VALUEFUNC(_wrap_OverlayElement__get_relative_height), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_get_clipping_region", VALUEFUNC(_wrap_OverlayElement__get_clipping_region), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_notify_zorder", VALUEFUNC(_wrap_OverlayElement__notify_zorder), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_notify_world_transforms", VALUEFUNC(_wrap_OverlayElement__notify_world_transforms), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_notify_viewport", VALUEFUNC(_wrap_OverlayElement__notify_viewport), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_update_render_queue", VALUEFUNC(_wrap_OverlayElement__update_render_queue), -1);
  rb_define_method(SwigClassOverlayElement.klass, "visit_renderables", VALUEFUNC(_wrap_OverlayElement_visit_renderables), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_type_name", VALUEFUNC(_wrap_OverlayElement_get_type_name), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_caption", VALUEFUNC(_wrap_OverlayElement_set_caption), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_caption", VALUEFUNC(_wrap_OverlayElement_get_caption), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_colour", VALUEFUNC(_wrap_OverlayElement_set_colour), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_colour", VALUEFUNC(_wrap_OverlayElement_get_colour), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_metrics_mode", VALUEFUNC(_wrap_OverlayElement_set_metrics_mode), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_metrics_mode", VALUEFUNC(_wrap_OverlayElement_get_metrics_mode), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_horizontal_alignment", VALUEFUNC(_wrap_OverlayElement_set_horizontal_alignment), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_horizontal_alignment", VALUEFUNC(_wrap_OverlayElement_get_horizontal_alignment), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_vertical_alignment", VALUEFUNC(_wrap_OverlayElement_set_vertical_alignment), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_vertical_alignment", VALUEFUNC(_wrap_OverlayElement_get_vertical_alignment), -1);
  rb_define_method(SwigClassOverlayElement.klass, "contains", VALUEFUNC(_wrap_OverlayElement_contains), -1);
  rb_define_method(SwigClassOverlayElement.klass, "find_element_at", VALUEFUNC(_wrap_OverlayElement_find_element_at), -1);
  rb_define_method(SwigClassOverlayElement.klass, "is_container", VALUEFUNC(_wrap_OverlayElement_is_container), -1);
  rb_define_method(SwigClassOverlayElement.klass, "is_key_enabled", VALUEFUNC(_wrap_OverlayElement_is_key_enabled), -1);
  rb_define_method(SwigClassOverlayElement.klass, "is_cloneable", VALUEFUNC(_wrap_OverlayElement_is_cloneable), -1);
  rb_define_method(SwigClassOverlayElement.klass, "set_cloneable", VALUEFUNC(_wrap_OverlayElement_set_cloneable), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_parent", VALUEFUNC(_wrap_OverlayElement_get_parent), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_set_parent", VALUEFUNC(_wrap_OverlayElement__set_parent), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_zorder", VALUEFUNC(_wrap_OverlayElement_get_zorder), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_squared_view_depth", VALUEFUNC(_wrap_OverlayElement_get_squared_view_depth), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_lights", VALUEFUNC(_wrap_OverlayElement_get_lights), -1);
  rb_define_method(SwigClassOverlayElement.klass, "copy_from_template", VALUEFUNC(_wrap_OverlayElement_copy_from_template), -1);
  rb_define_method(SwigClassOverlayElement.klass, "clone", VALUEFUNC(_wrap_OverlayElement_clone), -1);
  rb_define_method(SwigClassOverlayElement.klass, "get_source_template", VALUEFUNC(_wrap_OverlayElement_get_source_template), -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, "add_child", VALUEFUNC(_wrap_OverlayContainer_add_child), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "add_child_impl", VALUEFUNC(_wrap_OverlayContainer_add_child_impl), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "remove_child", VALUEFUNC(_wrap_OverlayContainer_remove_child), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "get_child", VALUEFUNC(_wrap_OverlayContainer_get_child), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "initialise", VALUEFUNC(_wrap_OverlayContainer_initialise), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_add_child", VALUEFUNC(_wrap_OverlayContainer__add_child), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_remove_child", VALUEFUNC(_wrap_OverlayContainer__remove_child), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "get_child_iterator", VALUEFUNC(_wrap_OverlayContainer_get_child_iterator), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "get_child_container_iterator", VALUEFUNC(_wrap_OverlayContainer_get_child_container_iterator), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_positions_out_of_date", VALUEFUNC(_wrap_OverlayContainer__positions_out_of_date), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_update", VALUEFUNC(_wrap_OverlayContainer__update), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_notify_zorder", VALUEFUNC(_wrap_OverlayContainer__notify_zorder), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_notify_viewport", VALUEFUNC(_wrap_OverlayContainer__notify_viewport), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_notify_world_transforms", VALUEFUNC(_wrap_OverlayContainer__notify_world_transforms), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_notify_parent", VALUEFUNC(_wrap_OverlayContainer__notify_parent), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_update_render_queue", VALUEFUNC(_wrap_OverlayContainer__update_render_queue), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "is_container", VALUEFUNC(_wrap_OverlayContainer_is_container), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "is_children_process_events", VALUEFUNC(_wrap_OverlayContainer_is_children_process_events), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "set_children_process_events", VALUEFUNC(_wrap_OverlayContainer_set_children_process_events), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "find_element_at", VALUEFUNC(_wrap_OverlayContainer_find_element_at), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "copy_from_template", VALUEFUNC(_wrap_OverlayContainer_copy_from_template), -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, "set_tiling", VALUEFUNC(_wrap_PanelOverlayElement_set_tiling), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "get_tile_x", VALUEFUNC(_wrap_PanelOverlayElement_get_tile_x), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "get_tile_y", VALUEFUNC(_wrap_PanelOverlayElement_get_tile_y), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "set_uv", VALUEFUNC(_wrap_PanelOverlayElement_set_uv), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "get_uv", VALUEFUNC(_wrap_PanelOverlayElement_get_uv), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "set_transparent", VALUEFUNC(_wrap_PanelOverlayElement_set_transparent), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "is_transparent", VALUEFUNC(_wrap_PanelOverlayElement_is_transparent), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "get_type_name", VALUEFUNC(_wrap_PanelOverlayElement_get_type_name), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "get_render_operation", VALUEFUNC(_wrap_PanelOverlayElement_get_render_operation), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "set_material_name", VALUEFUNC(_wrap_PanelOverlayElement_set_material_name), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "_update_render_queue", VALUEFUNC(_wrap_PanelOverlayElement__update_render_queue), -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, "get_type_name", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_type_name), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "set_border_size", VALUEFUNC(_wrap_BorderPanelOverlayElement_set_border_size), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_left_border_size", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_left_border_size), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_right_border_size", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_right_border_size), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_top_border_size", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_top_border_size), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_bottom_border_size", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_bottom_border_size), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "set_left_border_uv", VALUEFUNC(_wrap_BorderPanelOverlayElement_set_left_border_uv), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "set_right_border_uv", VALUEFUNC(_wrap_BorderPanelOverlayElement_set_right_border_uv), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "set_top_border_uv", VALUEFUNC(_wrap_BorderPanelOverlayElement_set_top_border_uv), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "set_bottom_border_uv", VALUEFUNC(_wrap_BorderPanelOverlayElement_set_bottom_border_uv), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "set_top_left_border_uv", VALUEFUNC(_wrap_BorderPanelOverlayElement_set_top_left_border_uv), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "set_top_right_border_uv", VALUEFUNC(_wrap_BorderPanelOverlayElement_set_top_right_border_uv), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "set_bottom_left_border_uv", VALUEFUNC(_wrap_BorderPanelOverlayElement_set_bottom_left_border_uv), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "set_bottom_right_border_uv", VALUEFUNC(_wrap_BorderPanelOverlayElement_set_bottom_right_border_uv), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_left_border_uvstring", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_left_border_uvstring), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_right_border_uvstring", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_right_border_uvstring), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_top_border_uvstring", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_top_border_uvstring), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_bottom_border_uvstring", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_bottom_border_uvstring), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_top_left_border_uvstring", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_top_left_border_uvstring), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_top_right_border_uvstring", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_top_right_border_uvstring), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_bottom_left_border_uvstring", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_bottom_left_border_uvstring), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_bottom_right_border_uvstring", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_bottom_right_border_uvstring), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "set_border_material_name", VALUEFUNC(_wrap_BorderPanelOverlayElement_set_border_material_name), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "get_border_material_name", VALUEFUNC(_wrap_BorderPanelOverlayElement_get_border_material_name), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "_update_render_queue", VALUEFUNC(_wrap_BorderPanelOverlayElement__update_render_queue), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "visit_renderables", VALUEFUNC(_wrap_BorderPanelOverlayElement_visit_renderables), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "set_metrics_mode", VALUEFUNC(_wrap_BorderPanelOverlayElement_set_metrics_mode), -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, "get_material", VALUEFUNC(_wrap_BorderRenderable_get_material), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "get_render_operation", VALUEFUNC(_wrap_BorderRenderable_get_render_operation), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "get_world_transforms", VALUEFUNC(_wrap_BorderRenderable_get_world_transforms), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "get_num_world_transforms", VALUEFUNC(_wrap_BorderRenderable_get_num_world_transforms), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "get_squared_view_depth", VALUEFUNC(_wrap_BorderRenderable_get_squared_view_depth), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "get_lights", VALUEFUNC(_wrap_BorderRenderable_get_lights), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "get_polygon_mode_overrideable", VALUEFUNC(_wrap_BorderRenderable_get_polygon_mode_overrideable), -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, "set_fovy", VALUEFUNC(_wrap_Frustum_set_fovy), -1);
  rb_define_method(SwigClassFrustum.klass, "get_fovy", VALUEFUNC(_wrap_Frustum_get_fovy), -1);
  rb_define_method(SwigClassFrustum.klass, "set_near_clip_distance", VALUEFUNC(_wrap_Frustum_set_near_clip_distance), -1);
  rb_define_method(SwigClassFrustum.klass, "get_near_clip_distance", VALUEFUNC(_wrap_Frustum_get_near_clip_distance), -1);
  rb_define_method(SwigClassFrustum.klass, "set_far_clip_distance", VALUEFUNC(_wrap_Frustum_set_far_clip_distance), -1);
  rb_define_method(SwigClassFrustum.klass, "get_far_clip_distance", VALUEFUNC(_wrap_Frustum_get_far_clip_distance), -1);
  rb_define_method(SwigClassFrustum.klass, "set_aspect_ratio", VALUEFUNC(_wrap_Frustum_set_aspect_ratio), -1);
  rb_define_method(SwigClassFrustum.klass, "get_aspect_ratio", VALUEFUNC(_wrap_Frustum_get_aspect_ratio), -1);
  rb_define_method(SwigClassFrustum.klass, "set_frustum_offset", VALUEFUNC(_wrap_Frustum_set_frustum_offset), -1);
  rb_define_method(SwigClassFrustum.klass, "get_frustum_offset", VALUEFUNC(_wrap_Frustum_get_frustum_offset), -1);
  rb_define_method(SwigClassFrustum.klass, "set_focal_length", VALUEFUNC(_wrap_Frustum_set_focal_length), -1);
  rb_define_method(SwigClassFrustum.klass, "get_focal_length", VALUEFUNC(_wrap_Frustum_get_focal_length), -1);
  rb_define_method(SwigClassFrustum.klass, "set_frustum_extents", VALUEFUNC(_wrap_Frustum_set_frustum_extents), -1);
  rb_define_method(SwigClassFrustum.klass, "reset_frustum_extents", VALUEFUNC(_wrap_Frustum_reset_frustum_extents), -1);
  rb_define_method(SwigClassFrustum.klass, "get_frustum_extents", VALUEFUNC(_wrap_Frustum_get_frustum_extents), -1);
  rb_define_method(SwigClassFrustum.klass, "get_projection_matrix_rs", VALUEFUNC(_wrap_Frustum_get_projection_matrix_rs), -1);
  rb_define_method(SwigClassFrustum.klass, "get_projection_matrix_with_rsdepth", VALUEFUNC(_wrap_Frustum_get_projection_matrix_with_rsdepth), -1);
  rb_define_method(SwigClassFrustum.klass, "get_projection_matrix", VALUEFUNC(_wrap_Frustum_get_projection_matrix), -1);
  rb_define_method(SwigClassFrustum.klass, "get_view_matrix", VALUEFUNC(_wrap_Frustum_get_view_matrix), -1);
  rb_define_method(SwigClassFrustum.klass, "calc_view_matrix_relative", VALUEFUNC(_wrap_Frustum_calc_view_matrix_relative), -1);
  rb_define_method(SwigClassFrustum.klass, "set_custom_view_matrix", VALUEFUNC(_wrap_Frustum_set_custom_view_matrix), -1);
  rb_define_method(SwigClassFrustum.klass, "is_custom_view_matrix_enabled", VALUEFUNC(_wrap_Frustum_is_custom_view_matrix_enabled), -1);
  rb_define_method(SwigClassFrustum.klass, "set_custom_projection_matrix", VALUEFUNC(_wrap_Frustum_set_custom_projection_matrix), -1);
  rb_define_method(SwigClassFrustum.klass, "is_custom_projection_matrix_enabled", VALUEFUNC(_wrap_Frustum_is_custom_projection_matrix_enabled), -1);
  rb_define_method(SwigClassFrustum.klass, "get_frustum_planes", VALUEFUNC(_wrap_Frustum_get_frustum_planes), -1);
  rb_define_method(SwigClassFrustum.klass, "get_frustum_plane", VALUEFUNC(_wrap_Frustum_get_frustum_plane), -1);
  rb_define_method(SwigClassFrustum.klass, "is_visible", VALUEFUNC(_wrap_Frustum_is_visible), -1);
  rb_define_method(SwigClassFrustum.klass, "get_type_flags", VALUEFUNC(_wrap_Frustum_get_type_flags), -1);
  rb_define_method(SwigClassFrustum.klass, "get_bounding_box", VALUEFUNC(_wrap_Frustum_get_bounding_box), -1);
  rb_define_method(SwigClassFrustum.klass, "get_bounding_radius", VALUEFUNC(_wrap_Frustum_get_bounding_radius), -1);
  rb_define_method(SwigClassFrustum.klass, "_update_render_queue", VALUEFUNC(_wrap_Frustum__update_render_queue), -1);
  rb_define_method(SwigClassFrustum.klass, "get_movable_type", VALUEFUNC(_wrap_Frustum_get_movable_type), -1);
  rb_define_method(SwigClassFrustum.klass, "_notify_current_camera", VALUEFUNC(_wrap_Frustum__notify_current_camera), -1);
  rb_define_method(SwigClassFrustum.klass, "get_material", VALUEFUNC(_wrap_Frustum_get_material), -1);
  rb_define_method(SwigClassFrustum.klass, "get_render_operation", VALUEFUNC(_wrap_Frustum_get_render_operation), -1);
  rb_define_method(SwigClassFrustum.klass, "get_world_transforms", VALUEFUNC(_wrap_Frustum_get_world_transforms), -1);
  rb_define_method(SwigClassFrustum.klass, "get_squared_view_depth", VALUEFUNC(_wrap_Frustum_get_squared_view_depth), -1);
  rb_define_method(SwigClassFrustum.klass, "get_lights", VALUEFUNC(_wrap_Frustum_get_lights), -1);
  rb_define_method(SwigClassFrustum.klass, "get_world_space_corners", VALUEFUNC(_wrap_Frustum_get_world_space_corners), -1);
  rb_define_method(SwigClassFrustum.klass, "set_projection_type", VALUEFUNC(_wrap_Frustum_set_projection_type), -1);
  rb_define_method(SwigClassFrustum.klass, "get_projection_type", VALUEFUNC(_wrap_Frustum_get_projection_type), -1);
  rb_define_method(SwigClassFrustum.klass, "set_ortho_window", VALUEFUNC(_wrap_Frustum_set_ortho_window), -1);
  rb_define_method(SwigClassFrustum.klass, "set_ortho_window_height", VALUEFUNC(_wrap_Frustum_set_ortho_window_height), -1);
  rb_define_method(SwigClassFrustum.klass, "set_ortho_window_width", VALUEFUNC(_wrap_Frustum_set_ortho_window_width), -1);
  rb_define_method(SwigClassFrustum.klass, "get_ortho_window_height", VALUEFUNC(_wrap_Frustum_get_ortho_window_height), -1);
  rb_define_method(SwigClassFrustum.klass, "get_ortho_window_width", VALUEFUNC(_wrap_Frustum_get_ortho_window_width), -1);
  rb_define_method(SwigClassFrustum.klass, "enable_reflection", VALUEFUNC(_wrap_Frustum_enable_reflection), -1);
  rb_define_method(SwigClassFrustum.klass, "disable_reflection", VALUEFUNC(_wrap_Frustum_disable_reflection), -1);
  rb_define_method(SwigClassFrustum.klass, "is_reflected", VALUEFUNC(_wrap_Frustum_is_reflected), -1);
  rb_define_method(SwigClassFrustum.klass, "get_reflection_matrix", VALUEFUNC(_wrap_Frustum_get_reflection_matrix), -1);
  rb_define_method(SwigClassFrustum.klass, "get_reflection_plane", VALUEFUNC(_wrap_Frustum_get_reflection_plane), -1);
  rb_define_method(SwigClassFrustum.klass, "project_sphere", VALUEFUNC(_wrap_Frustum_project_sphere), -1);
  rb_define_method(SwigClassFrustum.klass, "enable_custom_near_clip_plane", VALUEFUNC(_wrap_Frustum_enable_custom_near_clip_plane), -1);
  rb_define_method(SwigClassFrustum.klass, "disable_custom_near_clip_plane", VALUEFUNC(_wrap_Frustum_disable_custom_near_clip_plane), -1);
  rb_define_method(SwigClassFrustum.klass, "is_custom_near_clip_plane_enabled", VALUEFUNC(_wrap_Frustum_is_custom_near_clip_plane_enabled), -1);
  rb_define_method(SwigClassFrustum.klass, "visit_renderables", VALUEFUNC(_wrap_Frustum_visit_renderables), -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, "get_position_for_view_update", VALUEFUNC(_wrap_Frustum_get_position_for_view_update), -1);
  rb_define_method(SwigClassFrustum.klass, "get_orientation_for_view_update", VALUEFUNC(_wrap_Frustum_get_orientation_for_view_update), -1);
  rb_define_method(SwigClassFrustum.klass, "get_plane_bounded_volume", VALUEFUNC(_wrap_Frustum_get_plane_bounded_volume), -1);
  rb_define_method(SwigClassFrustum.klass, "set_orientation_mode", VALUEFUNC(_wrap_Frustum_set_orientation_mode), -1);
  rb_define_method(SwigClassFrustum.klass, "get_orientation_mode", VALUEFUNC(_wrap_Frustum_get_orientation_mode), -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, "set_origin", VALUEFUNC(_wrap_Ray_set_origin), -1);
  rb_define_method(SwigClassRay.klass, "get_origin", VALUEFUNC(_wrap_Ray_get_origin), -1);
  rb_define_method(SwigClassRay.klass, "set_direction", VALUEFUNC(_wrap_Ray_set_direction), -1);
  rb_define_method(SwigClassRay.klass, "get_direction", VALUEFUNC(_wrap_Ray_get_direction), -1);
  rb_define_method(SwigClassRay.klass, "get_point", VALUEFUNC(_wrap_Ray_get_point), -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, "add_listener", VALUEFUNC(_wrap_Camera_add_listener), -1);
  rb_define_method(SwigClassCamera.klass, "remove_listener", VALUEFUNC(_wrap_Camera_remove_listener), -1);
  rb_define_method(SwigClassCamera.klass, "get_scene_manager", VALUEFUNC(_wrap_Camera_get_scene_manager), -1);
  rb_define_method(SwigClassCamera.klass, "set_polygon_mode", VALUEFUNC(_wrap_Camera_set_polygon_mode), -1);
  rb_define_method(SwigClassCamera.klass, "get_polygon_mode", VALUEFUNC(_wrap_Camera_get_polygon_mode), -1);
  rb_define_method(SwigClassCamera.klass, "set_position", VALUEFUNC(_wrap_Camera_set_position), -1);
  rb_define_method(SwigClassCamera.klass, "get_position", VALUEFUNC(_wrap_Camera_get_position), -1);
  rb_define_method(SwigClassCamera.klass, "move", VALUEFUNC(_wrap_Camera_move), -1);
  rb_define_method(SwigClassCamera.klass, "move_relative", VALUEFUNC(_wrap_Camera_move_relative), -1);
  rb_define_method(SwigClassCamera.klass, "set_direction", VALUEFUNC(_wrap_Camera_set_direction), -1);
  rb_define_method(SwigClassCamera.klass, "get_direction", VALUEFUNC(_wrap_Camera_get_direction), -1);
  rb_define_method(SwigClassCamera.klass, "get_up", VALUEFUNC(_wrap_Camera_get_up), -1);
  rb_define_method(SwigClassCamera.klass, "get_right", VALUEFUNC(_wrap_Camera_get_right), -1);
  rb_define_method(SwigClassCamera.klass, "look_at", VALUEFUNC(_wrap_Camera_look_at), -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, "set_fixed_yaw_axis", VALUEFUNC(_wrap_Camera_set_fixed_yaw_axis), -1);
  rb_define_method(SwigClassCamera.klass, "get_orientation", VALUEFUNC(_wrap_Camera_get_orientation), -1);
  rb_define_method(SwigClassCamera.klass, "set_orientation", VALUEFUNC(_wrap_Camera_set_orientation), -1);
  rb_define_method(SwigClassCamera.klass, "_render_scene", VALUEFUNC(_wrap_Camera__render_scene), -1);
  rb_define_method(SwigClassCamera.klass, "_notify_rendered_faces", VALUEFUNC(_wrap_Camera__notify_rendered_faces), -1);
  rb_define_method(SwigClassCamera.klass, "_notify_rendered_batches", VALUEFUNC(_wrap_Camera__notify_rendered_batches), -1);
  rb_define_method(SwigClassCamera.klass, "_get_num_rendered_faces", VALUEFUNC(_wrap_Camera__get_num_rendered_faces), -1);
  rb_define_method(SwigClassCamera.klass, "_get_num_rendered_batches", VALUEFUNC(_wrap_Camera__get_num_rendered_batches), -1);
  rb_define_method(SwigClassCamera.klass, "get_derived_orientation", VALUEFUNC(_wrap_Camera_get_derived_orientation), -1);
  rb_define_method(SwigClassCamera.klass, "get_derived_position", VALUEFUNC(_wrap_Camera_get_derived_position), -1);
  rb_define_method(SwigClassCamera.klass, "get_derived_direction", VALUEFUNC(_wrap_Camera_get_derived_direction), -1);
  rb_define_method(SwigClassCamera.klass, "get_derived_up", VALUEFUNC(_wrap_Camera_get_derived_up), -1);
  rb_define_method(SwigClassCamera.klass, "get_derived_right", VALUEFUNC(_wrap_Camera_get_derived_right), -1);
  rb_define_method(SwigClassCamera.klass, "get_real_orientation", VALUEFUNC(_wrap_Camera_get_real_orientation), -1);
  rb_define_method(SwigClassCamera.klass, "get_real_position", VALUEFUNC(_wrap_Camera_get_real_position), -1);
  rb_define_method(SwigClassCamera.klass, "get_real_direction", VALUEFUNC(_wrap_Camera_get_real_direction), -1);
  rb_define_method(SwigClassCamera.klass, "get_real_up", VALUEFUNC(_wrap_Camera_get_real_up), -1);
  rb_define_method(SwigClassCamera.klass, "get_real_right", VALUEFUNC(_wrap_Camera_get_real_right), -1);
  rb_define_method(SwigClassCamera.klass, "get_world_transforms", VALUEFUNC(_wrap_Camera_get_world_transforms), -1);
  rb_define_method(SwigClassCamera.klass, "get_movable_type", VALUEFUNC(_wrap_Camera_get_movable_type), -1);
  rb_define_method(SwigClassCamera.klass, "set_auto_tracking", VALUEFUNC(_wrap_Camera_set_auto_tracking), -1);
  rb_define_method(SwigClassCamera.klass, "set_lod_bias", VALUEFUNC(_wrap_Camera_set_lod_bias), -1);
  rb_define_method(SwigClassCamera.klass, "get_lod_bias", VALUEFUNC(_wrap_Camera_get_lod_bias), -1);
  rb_define_method(SwigClassCamera.klass, "set_lod_camera", VALUEFUNC(_wrap_Camera_set_lod_camera), -1);
  rb_define_method(SwigClassCamera.klass, "get_lod_camera", VALUEFUNC(_wrap_Camera_get_lod_camera), -1);
  rb_define_method(SwigClassCamera.klass, "get_camera_to_viewport_ray", VALUEFUNC(_wrap_Camera_get_camera_to_viewport_ray), -1);
  rb_define_method(SwigClassCamera.klass, "get_camera_to_viewport_box_volume", VALUEFUNC(_wrap_Camera_get_camera_to_viewport_box_volume), -1);
  rb_define_method(SwigClassCamera.klass, "_get_lod_bias_inverse", VALUEFUNC(_wrap_Camera__get_lod_bias_inverse), -1);
  rb_define_method(SwigClassCamera.klass, "_auto_track", VALUEFUNC(_wrap_Camera__auto_track), -1);
  rb_define_method(SwigClassCamera.klass, "set_window", VALUEFUNC(_wrap_Camera_set_window), -1);
  rb_define_method(SwigClassCamera.klass, "reset_window", VALUEFUNC(_wrap_Camera_reset_window), -1);
  rb_define_method(SwigClassCamera.klass, "is_window_set", VALUEFUNC(_wrap_Camera_is_window_set), -1);
  rb_define_method(SwigClassCamera.klass, "get_window_planes", VALUEFUNC(_wrap_Camera_get_window_planes), -1);
  rb_define_method(SwigClassCamera.klass, "get_bounding_radius", VALUEFUNC(_wrap_Camera_get_bounding_radius), -1);
  rb_define_method(SwigClassCamera.klass, "get_auto_track_target", VALUEFUNC(_wrap_Camera_get_auto_track_target), -1);
  rb_define_method(SwigClassCamera.klass, "get_auto_track_offset", VALUEFUNC(_wrap_Camera_get_auto_track_offset), -1);
  rb_define_method(SwigClassCamera.klass, "get_viewport", VALUEFUNC(_wrap_Camera_get_viewport), -1);
  rb_define_method(SwigClassCamera.klass, "_notify_viewport", VALUEFUNC(_wrap_Camera__notify_viewport), -1);
  rb_define_method(SwigClassCamera.klass, "set_auto_aspect_ratio", VALUEFUNC(_wrap_Camera_set_auto_aspect_ratio), -1);
  rb_define_method(SwigClassCamera.klass, "get_auto_aspect_ratio", VALUEFUNC(_wrap_Camera_get_auto_aspect_ratio), -1);
  rb_define_method(SwigClassCamera.klass, "set_culling_frustum", VALUEFUNC(_wrap_Camera_set_culling_frustum), -1);
  rb_define_method(SwigClassCamera.klass, "get_culling_frustum", VALUEFUNC(_wrap_Camera_get_culling_frustum), -1);
  rb_define_method(SwigClassCamera.klass, "forward_intersect", VALUEFUNC(_wrap_Camera_forward_intersect), -1);
  rb_define_method(SwigClassCamera.klass, "is_visible", VALUEFUNC(_wrap_Camera_is_visible), -1);
  rb_define_method(SwigClassCamera.klass, "get_world_space_corners", VALUEFUNC(_wrap_Camera_get_world_space_corners), -1);
  rb_define_method(SwigClassCamera.klass, "get_frustum_plane", VALUEFUNC(_wrap_Camera_get_frustum_plane), -1);
  rb_define_method(SwigClassCamera.klass, "project_sphere", VALUEFUNC(_wrap_Camera_project_sphere), -1);
  rb_define_method(SwigClassCamera.klass, "get_near_clip_distance", VALUEFUNC(_wrap_Camera_get_near_clip_distance), -1);
  rb_define_method(SwigClassCamera.klass, "get_far_clip_distance", VALUEFUNC(_wrap_Camera_get_far_clip_distance), -1);
  rb_define_method(SwigClassCamera.klass, "get_view_matrix", VALUEFUNC(_wrap_Camera_get_view_matrix), -1);
  rb_define_method(SwigClassCamera.klass, "set_use_rendering_distance", VALUEFUNC(_wrap_Camera_set_use_rendering_distance), -1);
  rb_define_method(SwigClassCamera.klass, "get_use_rendering_distance", VALUEFUNC(_wrap_Camera_get_use_rendering_distance), -1);
  rb_define_method(SwigClassCamera.klass, "synchronise_base_settings_with", VALUEFUNC(_wrap_Camera_synchronise_base_settings_with), -1);
  rb_define_method(SwigClassCamera.klass, "get_position_for_view_update", VALUEFUNC(_wrap_Camera_get_position_for_view_update), -1);
  rb_define_method(SwigClassCamera.klass, "get_orientation_for_view_update", VALUEFUNC(_wrap_Camera_get_orientation_for_view_update), -1);
  rb_define_method(SwigClassCamera.klass, "set_use_min_pixel_size", VALUEFUNC(_wrap_Camera_set_use_min_pixel_size), -1);
  rb_define_method(SwigClassCamera.klass, "get_use_min_pixel_size", VALUEFUNC(_wrap_Camera_get_use_min_pixel_size), -1);
  rb_define_method(SwigClassCamera.klass, "get_pixel_display_ratio", VALUEFUNC(_wrap_Camera_get_pixel_display_ratio), -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, "register_codec", VALUEFUNC(_wrap_Codec_register_codec), -1);
  rb_define_singleton_method(SwigClassCodec.klass, "is_codec_registered", VALUEFUNC(_wrap_Codec_is_codec_registered), -1);
  rb_define_singleton_method(SwigClassCodec.klass, "un_register_codec", VALUEFUNC(_wrap_Codec_un_register_codec), -1);
  rb_define_singleton_method(SwigClassCodec.klass, "get_codec_iterator", VALUEFUNC(_wrap_Codec_get_codec_iterator), -1);
  rb_define_singleton_method(SwigClassCodec.klass, "get_extensions", VALUEFUNC(_wrap_Codec_get_extensions), -1);
  rb_define_singleton_method(SwigClassCodec.klass, "get_codec", VALUEFUNC(_wrap_Codec_get_codec), -1);
  rb_define_method(SwigClassCodec.klass, "code", VALUEFUNC(_wrap_Codec_code), -1);
  rb_define_method(SwigClassCodec.klass, "code_to_file", VALUEFUNC(_wrap_Codec_code_to_file), -1);
  rb_define_method(SwigClassCodec.klass, "decode", VALUEFUNC(_wrap_Codec_decode), -1);
  rb_define_method(SwigClassCodec.klass, "get_type", VALUEFUNC(_wrap_Codec_get_type), -1);
  rb_define_method(SwigClassCodec.klass, "get_data_type", VALUEFUNC(_wrap_Codec_get_data_type), -1);
  rb_define_method(SwigClassCodec.klass, "magic_number_match", VALUEFUNC(_wrap_Codec_magic_number_match), -1);
  rb_define_method(SwigClassCodec.klass, "magic_number_to_file_ext", VALUEFUNC(_wrap_Codec_magic_number_to_file_ext), -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, "set_consecutive", VALUEFUNC(_wrap_PixelBox_set_consecutive), -1);
  rb_define_method(SwigClassPixelBox.klass, "get_row_skip", VALUEFUNC(_wrap_PixelBox_get_row_skip), -1);
  rb_define_method(SwigClassPixelBox.klass, "get_slice_skip", VALUEFUNC(_wrap_PixelBox_get_slice_skip), -1);
  rb_define_method(SwigClassPixelBox.klass, "is_consecutive", VALUEFUNC(_wrap_PixelBox_is_consecutive), -1);
  rb_define_method(SwigClassPixelBox.klass, "get_consecutive_size", VALUEFUNC(_wrap_PixelBox_get_consecutive_size), -1);
  rb_define_method(SwigClassPixelBox.klass, "get_sub_volume", VALUEFUNC(_wrap_PixelBox_get_sub_volume), -1);
  rb_define_method(SwigClassPixelBox.klass, "get_colour_at", VALUEFUNC(_wrap_PixelBox_get_colour_at), -1);
  rb_define_method(SwigClassPixelBox.klass, "set_colour_at", VALUEFUNC(_wrap_PixelBox_set_colour_at), -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, "get_num_elem_bytes", VALUEFUNC(_wrap_PixelUtil_get_num_elem_bytes), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "get_num_elem_bits", VALUEFUNC(_wrap_PixelUtil_get_num_elem_bits), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "get_memory_size", VALUEFUNC(_wrap_PixelUtil_get_memory_size), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "get_flags", VALUEFUNC(_wrap_PixelUtil_get_flags), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "has_alpha", VALUEFUNC(_wrap_PixelUtil_has_alpha), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "is_floating_point", VALUEFUNC(_wrap_PixelUtil_is_floating_point), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "is_compressed", VALUEFUNC(_wrap_PixelUtil_is_compressed), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "is_depth", VALUEFUNC(_wrap_PixelUtil_is_depth), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "is_native_endian", VALUEFUNC(_wrap_PixelUtil_is_native_endian), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "is_luminance", VALUEFUNC(_wrap_PixelUtil_is_luminance), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "is_valid_extent", VALUEFUNC(_wrap_PixelUtil_is_valid_extent), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "get_bit_depths", VALUEFUNC(_wrap_PixelUtil_get_bit_depths), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "get_bit_masks", VALUEFUNC(_wrap_PixelUtil_get_bit_masks), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "get_bit_shifts", VALUEFUNC(_wrap_PixelUtil_get_bit_shifts), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "get_format_name", VALUEFUNC(_wrap_PixelUtil_get_format_name), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "is_accessible", VALUEFUNC(_wrap_PixelUtil_is_accessible), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "get_component_type", VALUEFUNC(_wrap_PixelUtil_get_component_type), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "get_component_count", VALUEFUNC(_wrap_PixelUtil_get_component_count), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "get_format_from_name", VALUEFUNC(_wrap_PixelUtil_get_format_from_name), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "get_bnfexpression_of_pixel_formats", VALUEFUNC(_wrap_PixelUtil_get_bnfexpression_of_pixel_formats), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "get_format_for_bit_depths", VALUEFUNC(_wrap_PixelUtil_get_format_for_bit_depths), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "pack_colour", VALUEFUNC(_wrap_PixelUtil_pack_colour), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "unpack_colour", VALUEFUNC(_wrap_PixelUtil_unpack_colour), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "bulk_pixel_conversion", VALUEFUNC(_wrap_PixelUtil_bulk_pixel_conversion), -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, "flip_around_y", VALUEFUNC(_wrap_Image_flip_around_y), -1);
  rb_define_method(SwigClassImage.klass, "flip_around_x", VALUEFUNC(_wrap_Image_flip_around_x), -1);
  rb_define_method(SwigClassImage.klass, "load_dynamic_image", VALUEFUNC(_wrap_Image_load_dynamic_image), -1);
  rb_define_method(SwigClassImage.klass, "load_raw_data", VALUEFUNC(_wrap_Image_load_raw_data), -1);
  rb_define_method(SwigClassImage.klass, "load", VALUEFUNC(_wrap_Image_load), -1);
  rb_define_method(SwigClassImage.klass, "load_two_images_as_rgba", VALUEFUNC(_wrap_Image_load_two_images_as_rgba), -1);
  rb_define_method(SwigClassImage.klass, "combine_two_images_as_rgba", VALUEFUNC(_wrap_Image_combine_two_images_as_rgba), -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, "get_data", VALUEFUNC(_wrap_Image_get_data), -1);
  rb_define_method(SwigClassImage.klass, "get_size", VALUEFUNC(_wrap_Image_get_size), -1);
  rb_define_method(SwigClassImage.klass, "get_num_mipmaps", VALUEFUNC(_wrap_Image_get_num_mipmaps), -1);
  rb_define_method(SwigClassImage.klass, "has_flag", VALUEFUNC(_wrap_Image_has_flag), -1);
  rb_define_method(SwigClassImage.klass, "get_width", VALUEFUNC(_wrap_Image_get_width), -1);
  rb_define_method(SwigClassImage.klass, "get_height", VALUEFUNC(_wrap_Image_get_height), -1);
  rb_define_method(SwigClassImage.klass, "get_depth", VALUEFUNC(_wrap_Image_get_depth), -1);
  rb_define_method(SwigClassImage.klass, "get_num_faces", VALUEFUNC(_wrap_Image_get_num_faces), -1);
  rb_define_method(SwigClassImage.klass, "get_row_span", VALUEFUNC(_wrap_Image_get_row_span), -1);
  rb_define_method(SwigClassImage.klass, "get_format", VALUEFUNC(_wrap_Image_get_format), -1);
  rb_define_method(SwigClassImage.klass, "get_bpp", VALUEFUNC(_wrap_Image_get_bpp), -1);
  rb_define_method(SwigClassImage.klass, "get_has_alpha", VALUEFUNC(_wrap_Image_get_has_alpha), -1);
  rb_define_singleton_method(SwigClassImage.klass, "apply_gamma", VALUEFUNC(_wrap_Image_apply_gamma), -1);
  rb_define_method(SwigClassImage.klass, "get_colour_at", VALUEFUNC(_wrap_Image_get_colour_at), -1);
  rb_define_method(SwigClassImage.klass, "set_colour_at", VALUEFUNC(_wrap_Image_set_colour_at), -1);
  rb_define_method(SwigClassImage.klass, "get_pixel_box", VALUEFUNC(_wrap_Image_get_pixel_box), -1);
  rb_define_method(SwigClassImage.klass, "free_memory", VALUEFUNC(_wrap_Image_free_memory), -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, "calculate_size", VALUEFUNC(_wrap_Image_calculate_size), -1);
  rb_define_singleton_method(SwigClassImage.klass, "get_file_ext_from_magic", VALUEFUNC(_wrap_Image_get_file_ext_from_magic), -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, "set_texture_type", VALUEFUNC(_wrap_Texture_set_texture_type), -1);
  rb_define_method(SwigClassTexture.klass, "get_texture_type", VALUEFUNC(_wrap_Texture_get_texture_type), -1);
  rb_define_method(SwigClassTexture.klass, "get_num_mipmaps", VALUEFUNC(_wrap_Texture_get_num_mipmaps), -1);
  rb_define_method(SwigClassTexture.klass, "set_num_mipmaps", VALUEFUNC(_wrap_Texture_set_num_mipmaps), -1);
  rb_define_method(SwigClassTexture.klass, "get_mipmaps_hardware_generated", VALUEFUNC(_wrap_Texture_get_mipmaps_hardware_generated), -1);
  rb_define_method(SwigClassTexture.klass, "get_gamma", VALUEFUNC(_wrap_Texture_get_gamma), -1);
  rb_define_method(SwigClassTexture.klass, "set_gamma", VALUEFUNC(_wrap_Texture_set_gamma), -1);
  rb_define_method(SwigClassTexture.klass, "set_hardware_gamma_enabled", VALUEFUNC(_wrap_Texture_set_hardware_gamma_enabled), -1);
  rb_define_method(SwigClassTexture.klass, "is_hardware_gamma_enabled", VALUEFUNC(_wrap_Texture_is_hardware_gamma_enabled), -1);
  rb_define_method(SwigClassTexture.klass, "set_fsaa", VALUEFUNC(_wrap_Texture_set_fsaa), -1);
  rb_define_method(SwigClassTexture.klass, "get_fsaa", VALUEFUNC(_wrap_Texture_get_fsaa), -1);
  rb_define_method(SwigClassTexture.klass, "get_fsaahint", VALUEFUNC(_wrap_Texture_get_fsaahint), -1);
  rb_define_method(SwigClassTexture.klass, "get_height", VALUEFUNC(_wrap_Texture_get_height), -1);
  rb_define_method(SwigClassTexture.klass, "get_width", VALUEFUNC(_wrap_Texture_get_width), -1);
  rb_define_method(SwigClassTexture.klass, "get_depth", VALUEFUNC(_wrap_Texture_get_depth), -1);
  rb_define_method(SwigClassTexture.klass, "get_src_height", VALUEFUNC(_wrap_Texture_get_src_height), -1);
  rb_define_method(SwigClassTexture.klass, "get_src_width", VALUEFUNC(_wrap_Texture_get_src_width), -1);
  rb_define_method(SwigClassTexture.klass, "get_src_depth", VALUEFUNC(_wrap_Texture_get_src_depth), -1);
  rb_define_method(SwigClassTexture.klass, "set_height", VALUEFUNC(_wrap_Texture_set_height), -1);
  rb_define_method(SwigClassTexture.klass, "set_width", VALUEFUNC(_wrap_Texture_set_width), -1);
  rb_define_method(SwigClassTexture.klass, "set_depth", VALUEFUNC(_wrap_Texture_set_depth), -1);
  rb_define_method(SwigClassTexture.klass, "get_usage", VALUEFUNC(_wrap_Texture_get_usage), -1);
  rb_define_method(SwigClassTexture.klass, "set_usage", VALUEFUNC(_wrap_Texture_set_usage), -1);
  rb_define_method(SwigClassTexture.klass, "create_internal_resources", VALUEFUNC(_wrap_Texture_create_internal_resources), -1);
  rb_define_method(SwigClassTexture.klass, "free_internal_resources", VALUEFUNC(_wrap_Texture_free_internal_resources), -1);
  rb_define_method(SwigClassTexture.klass, "copy_to_texture", VALUEFUNC(_wrap_Texture_copy_to_texture), -1);
  rb_define_method(SwigClassTexture.klass, "load_image", VALUEFUNC(_wrap_Texture_load_image), -1);
  rb_define_method(SwigClassTexture.klass, "load_raw_data", VALUEFUNC(_wrap_Texture_load_raw_data), -1);
  rb_define_method(SwigClassTexture.klass, "_load_images", VALUEFUNC(_wrap_Texture__load_images), -1);
  rb_define_method(SwigClassTexture.klass, "get_format", VALUEFUNC(_wrap_Texture_get_format), -1);
  rb_define_method(SwigClassTexture.klass, "get_desired_format", VALUEFUNC(_wrap_Texture_get_desired_format), -1);
  rb_define_method(SwigClassTexture.klass, "get_src_format", VALUEFUNC(_wrap_Texture_get_src_format), -1);
  rb_define_method(SwigClassTexture.klass, "set_format", VALUEFUNC(_wrap_Texture_set_format), -1);
  rb_define_method(SwigClassTexture.klass, "has_alpha", VALUEFUNC(_wrap_Texture_has_alpha), -1);
  rb_define_method(SwigClassTexture.klass, "set_desired_integer_bit_depth", VALUEFUNC(_wrap_Texture_set_desired_integer_bit_depth), -1);
  rb_define_method(SwigClassTexture.klass, "get_desired_integer_bit_depth", VALUEFUNC(_wrap_Texture_get_desired_integer_bit_depth), -1);
  rb_define_method(SwigClassTexture.klass, "set_desired_float_bit_depth", VALUEFUNC(_wrap_Texture_set_desired_float_bit_depth), -1);
  rb_define_method(SwigClassTexture.klass, "get_desired_float_bit_depth", VALUEFUNC(_wrap_Texture_get_desired_float_bit_depth), -1);
  rb_define_method(SwigClassTexture.klass, "set_desired_bit_depths", VALUEFUNC(_wrap_Texture_set_desired_bit_depths), -1);
  rb_define_method(SwigClassTexture.klass, "set_treat_luminance_as_alpha", VALUEFUNC(_wrap_Texture_set_treat_luminance_as_alpha), -1);
  rb_define_method(SwigClassTexture.klass, "get_treat_luminance_as_alpha", VALUEFUNC(_wrap_Texture_get_treat_luminance_as_alpha), -1);
  rb_define_method(SwigClassTexture.klass, "get_num_faces", VALUEFUNC(_wrap_Texture_get_num_faces), -1);
  rb_define_method(SwigClassTexture.klass, "get_buffer", VALUEFUNC(_wrap_Texture_get_buffer), -1);
  rb_define_method(SwigClassTexture.klass, "convert_to_image", VALUEFUNC(_wrap_Texture_convert_to_image), -1);
  rb_define_method(SwigClassTexture.klass, "get_custom_attribute", VALUEFUNC(_wrap_Texture_get_custom_attribute), -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, "get_texture_name", VALUEFUNC(_wrap_TextureUnitState_get_texture_name), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_name", VALUEFUNC(_wrap_TextureUnitState_set_texture_name), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture", VALUEFUNC(_wrap_TextureUnitState_set_texture), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_cubic_texture_name", VALUEFUNC(_wrap_TextureUnitState_set_cubic_texture_name), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_cubic_texture", VALUEFUNC(_wrap_TextureUnitState_set_cubic_texture), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_animated_texture_name", VALUEFUNC(_wrap_TextureUnitState_set_animated_texture_name), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_dimensions", VALUEFUNC(_wrap_TextureUnitState_get_texture_dimensions), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_current_frame", VALUEFUNC(_wrap_TextureUnitState_set_current_frame), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_current_frame", VALUEFUNC(_wrap_TextureUnitState_get_current_frame), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_frame_texture_name", VALUEFUNC(_wrap_TextureUnitState_get_frame_texture_name), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_frame_texture_name", VALUEFUNC(_wrap_TextureUnitState_set_frame_texture_name), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "add_frame_texture_name", VALUEFUNC(_wrap_TextureUnitState_add_frame_texture_name), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "delete_frame_texture_name", VALUEFUNC(_wrap_TextureUnitState_delete_frame_texture_name), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_num_frames", VALUEFUNC(_wrap_TextureUnitState_get_num_frames), -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, "set_binding_type", VALUEFUNC(_wrap_TextureUnitState_set_binding_type), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_binding_type", VALUEFUNC(_wrap_TextureUnitState_get_binding_type), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_content_type", VALUEFUNC(_wrap_TextureUnitState_set_content_type), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_content_type", VALUEFUNC(_wrap_TextureUnitState_get_content_type), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "is_cubic", VALUEFUNC(_wrap_TextureUnitState_is_cubic), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "is_3d", VALUEFUNC(_wrap_TextureUnitState_is_3d), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_type", VALUEFUNC(_wrap_TextureUnitState_get_texture_type), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_desired_format", VALUEFUNC(_wrap_TextureUnitState_set_desired_format), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_desired_format", VALUEFUNC(_wrap_TextureUnitState_get_desired_format), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_num_mipmaps", VALUEFUNC(_wrap_TextureUnitState_set_num_mipmaps), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_num_mipmaps", VALUEFUNC(_wrap_TextureUnitState_get_num_mipmaps), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_is_alpha", VALUEFUNC(_wrap_TextureUnitState_set_is_alpha), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_is_alpha", VALUEFUNC(_wrap_TextureUnitState_get_is_alpha), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_hardware_gamma_enabled", VALUEFUNC(_wrap_TextureUnitState_set_hardware_gamma_enabled), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "is_hardware_gamma_enabled", VALUEFUNC(_wrap_TextureUnitState_is_hardware_gamma_enabled), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_coord_set", VALUEFUNC(_wrap_TextureUnitState_get_texture_coord_set), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_coord_set", VALUEFUNC(_wrap_TextureUnitState_set_texture_coord_set), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_transform", VALUEFUNC(_wrap_TextureUnitState_set_texture_transform), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_transform", VALUEFUNC(_wrap_TextureUnitState_get_texture_transform), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_scroll", VALUEFUNC(_wrap_TextureUnitState_set_texture_scroll), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_uscroll", VALUEFUNC(_wrap_TextureUnitState_set_texture_uscroll), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_uscroll", VALUEFUNC(_wrap_TextureUnitState_get_texture_uscroll), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_vscroll", VALUEFUNC(_wrap_TextureUnitState_set_texture_vscroll), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_vscroll", VALUEFUNC(_wrap_TextureUnitState_get_texture_vscroll), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_uscale", VALUEFUNC(_wrap_TextureUnitState_set_texture_uscale), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_uscale", VALUEFUNC(_wrap_TextureUnitState_get_texture_uscale), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_vscale", VALUEFUNC(_wrap_TextureUnitState_set_texture_vscale), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_vscale", VALUEFUNC(_wrap_TextureUnitState_get_texture_vscale), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_scale", VALUEFUNC(_wrap_TextureUnitState_set_texture_scale), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_rotate", VALUEFUNC(_wrap_TextureUnitState_set_texture_rotate), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_rotate", VALUEFUNC(_wrap_TextureUnitState_get_texture_rotate), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_addressing_mode", VALUEFUNC(_wrap_TextureUnitState_get_texture_addressing_mode), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_addressing_mode", VALUEFUNC(_wrap_TextureUnitState_set_texture_addressing_mode), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_border_colour", VALUEFUNC(_wrap_TextureUnitState_set_texture_border_colour), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_border_colour", VALUEFUNC(_wrap_TextureUnitState_get_texture_border_colour), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_colour_operation_ex", VALUEFUNC(_wrap_TextureUnitState_set_colour_operation_ex), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_colour_operation", VALUEFUNC(_wrap_TextureUnitState_set_colour_operation), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_colour_op_multipass_fallback", VALUEFUNC(_wrap_TextureUnitState_set_colour_op_multipass_fallback), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_colour_blend_mode", VALUEFUNC(_wrap_TextureUnitState_get_colour_blend_mode), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_alpha_blend_mode", VALUEFUNC(_wrap_TextureUnitState_get_alpha_blend_mode), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_colour_blend_fallback_src", VALUEFUNC(_wrap_TextureUnitState_get_colour_blend_fallback_src), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_colour_blend_fallback_dest", VALUEFUNC(_wrap_TextureUnitState_get_colour_blend_fallback_dest), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_alpha_operation", VALUEFUNC(_wrap_TextureUnitState_set_alpha_operation), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "add_effect", VALUEFUNC(_wrap_TextureUnitState_add_effect), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_environment_map", VALUEFUNC(_wrap_TextureUnitState_set_environment_map), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_scroll_animation", VALUEFUNC(_wrap_TextureUnitState_set_scroll_animation), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_rotate_animation", VALUEFUNC(_wrap_TextureUnitState_set_rotate_animation), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_transform_animation", VALUEFUNC(_wrap_TextureUnitState_set_transform_animation), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_projective_texturing", VALUEFUNC(_wrap_TextureUnitState_set_projective_texturing), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "remove_all_effects", VALUEFUNC(_wrap_TextureUnitState_remove_all_effects), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "remove_effect", VALUEFUNC(_wrap_TextureUnitState_remove_effect), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "is_blank", VALUEFUNC(_wrap_TextureUnitState_is_blank), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_blank", VALUEFUNC(_wrap_TextureUnitState_set_blank), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "is_texture_load_failing", VALUEFUNC(_wrap_TextureUnitState_is_texture_load_failing), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "retry_texture_load", VALUEFUNC(_wrap_TextureUnitState_retry_texture_load), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_effects", VALUEFUNC(_wrap_TextureUnitState_get_effects), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_animation_duration", VALUEFUNC(_wrap_TextureUnitState_get_animation_duration), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_filtering", VALUEFUNC(_wrap_TextureUnitState_set_texture_filtering), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_filtering", VALUEFUNC(_wrap_TextureUnitState_get_texture_filtering), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_anisotropy", VALUEFUNC(_wrap_TextureUnitState_set_texture_anisotropy), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_anisotropy", VALUEFUNC(_wrap_TextureUnitState_get_texture_anisotropy), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_mipmap_bias", VALUEFUNC(_wrap_TextureUnitState_set_texture_mipmap_bias), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_mipmap_bias", VALUEFUNC(_wrap_TextureUnitState_get_texture_mipmap_bias), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_compositor_reference", VALUEFUNC(_wrap_TextureUnitState_set_compositor_reference), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_referenced_compositor_name", VALUEFUNC(_wrap_TextureUnitState_get_referenced_compositor_name), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_referenced_texture_name", VALUEFUNC(_wrap_TextureUnitState_get_referenced_texture_name), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_referenced_mrtindex", VALUEFUNC(_wrap_TextureUnitState_get_referenced_mrtindex), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_parent", VALUEFUNC(_wrap_TextureUnitState_get_parent), -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, "has_view_relative_texture_coordinate_generation", VALUEFUNC(_wrap_TextureUnitState_has_view_relative_texture_coordinate_generation), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "is_loaded", VALUEFUNC(_wrap_TextureUnitState_is_loaded), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_notify_needs_recompile", VALUEFUNC(_wrap_TextureUnitState__notify_needs_recompile), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_name", VALUEFUNC(_wrap_TextureUnitState_set_name), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_name", VALUEFUNC(_wrap_TextureUnitState_get_name), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "set_texture_name_alias", VALUEFUNC(_wrap_TextureUnitState_set_texture_name_alias), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "get_texture_name_alias", VALUEFUNC(_wrap_TextureUnitState_get_texture_name_alias), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "apply_texture_aliases", VALUEFUNC(_wrap_TextureUnitState_apply_texture_aliases), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_notify_parent", VALUEFUNC(_wrap_TextureUnitState__notify_parent), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_get_texture_ptr", VALUEFUNC(_wrap_TextureUnitState__get_texture_ptr), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_set_texture_ptr", VALUEFUNC(_wrap_TextureUnitState__set_texture_ptr), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_get_anim_controller", VALUEFUNC(_wrap_TextureUnitState__get_anim_controller), -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, "queue_for_export", VALUEFUNC(_wrap_MaterialSerializer_queue_for_export), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "export_queued", VALUEFUNC(_wrap_MaterialSerializer_export_queued), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "export_material", VALUEFUNC(_wrap_MaterialSerializer_export_material), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "get_queued_as_string", VALUEFUNC(_wrap_MaterialSerializer_get_queued_as_string), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "clear_queue", VALUEFUNC(_wrap_MaterialSerializer_clear_queue), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "parse_script", VALUEFUNC(_wrap_MaterialSerializer_parse_script), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "add_listener", VALUEFUNC(_wrap_MaterialSerializer_add_listener), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "remove_listener", VALUEFUNC(_wrap_MaterialSerializer_remove_listener), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "begin_section", VALUEFUNC(_wrap_MaterialSerializer_begin_section), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "end_section", VALUEFUNC(_wrap_MaterialSerializer_end_section), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "write_attribute", VALUEFUNC(_wrap_MaterialSerializer_write_attribute), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "write_value", VALUEFUNC(_wrap_MaterialSerializer_write_value), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "quote_word", VALUEFUNC(_wrap_MaterialSerializer_quote_word), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "write_comment", VALUEFUNC(_wrap_MaterialSerializer_write_comment), -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, "parse_script", VALUEFUNC(_wrap_MaterialManager_parse_script), -1);
  rb_define_method(SwigClassMaterialManager.klass, "set_default_texture_filtering", VALUEFUNC(_wrap_MaterialManager_set_default_texture_filtering), -1);
  rb_define_method(SwigClassMaterialManager.klass, "get_default_texture_filtering", VALUEFUNC(_wrap_MaterialManager_get_default_texture_filtering), -1);
  rb_define_method(SwigClassMaterialManager.klass, "set_default_anisotropy", VALUEFUNC(_wrap_MaterialManager_set_default_anisotropy), -1);
  rb_define_method(SwigClassMaterialManager.klass, "get_default_anisotropy", VALUEFUNC(_wrap_MaterialManager_get_default_anisotropy), -1);
  rb_define_method(SwigClassMaterialManager.klass, "get_default_settings", VALUEFUNC(_wrap_MaterialManager_get_default_settings), -1);
  rb_define_method(SwigClassMaterialManager.klass, "_get_scheme_index", VALUEFUNC(_wrap_MaterialManager__get_scheme_index), -1);
  rb_define_method(SwigClassMaterialManager.klass, "_get_scheme_name", VALUEFUNC(_wrap_MaterialManager__get_scheme_name), -1);
  rb_define_method(SwigClassMaterialManager.klass, "_get_active_scheme_index", VALUEFUNC(_wrap_MaterialManager__get_active_scheme_index), -1);
  rb_define_method(SwigClassMaterialManager.klass, "get_active_scheme", VALUEFUNC(_wrap_MaterialManager_get_active_scheme), -1);
  rb_define_method(SwigClassMaterialManager.klass, "set_active_scheme", VALUEFUNC(_wrap_MaterialManager_set_active_scheme), -1);
  rb_define_method(SwigClassMaterialManager.klass, "add_listener", VALUEFUNC(_wrap_MaterialManager_add_listener), -1);
  rb_define_method(SwigClassMaterialManager.klass, "remove_listener", VALUEFUNC(_wrap_MaterialManager_remove_listener), -1);
  rb_define_method(SwigClassMaterialManager.klass, "_arbitrate_missing_technique_for_active_scheme", VALUEFUNC(_wrap_MaterialManager__arbitrate_missing_technique_for_active_scheme), -1);
  rb_define_singleton_method(SwigClassMaterialManager.klass, "get_singleton", VALUEFUNC(_wrap_MaterialManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassMaterialManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_MaterialManager_get_singleton_ptr), -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, "to_string", VALUEFUNC(_wrap_StringConverter_to_string), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_real", VALUEFUNC(_wrap_StringConverter_parse_real), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_angle", VALUEFUNC(_wrap_StringConverter_parse_angle), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_int", VALUEFUNC(_wrap_StringConverter_parse_int), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_unsigned_int", VALUEFUNC(_wrap_StringConverter_parse_unsigned_int), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_long", VALUEFUNC(_wrap_StringConverter_parse_long), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_unsigned_long", VALUEFUNC(_wrap_StringConverter_parse_unsigned_long), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_size_t", VALUEFUNC(_wrap_StringConverter_parse_size_t), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_bool", VALUEFUNC(_wrap_StringConverter_parse_bool), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_vector2", VALUEFUNC(_wrap_StringConverter_parse_vector2), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_vector3", VALUEFUNC(_wrap_StringConverter_parse_vector3), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_vector4", VALUEFUNC(_wrap_StringConverter_parse_vector4), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_matrix3", VALUEFUNC(_wrap_StringConverter_parse_matrix3), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_matrix4", VALUEFUNC(_wrap_StringConverter_parse_matrix4), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_quaternion", VALUEFUNC(_wrap_StringConverter_parse_quaternion), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_colour_value", VALUEFUNC(_wrap_StringConverter_parse_colour_value), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parse_string_vector", VALUEFUNC(_wrap_StringConverter_parse_string_vector), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "is_number", VALUEFUNC(_wrap_StringConverter_is_number), -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, "message_logged", VALUEFUNC(_wrap_LogListener_message_logged), -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, "get_name", VALUEFUNC(_wrap_Log_get_name), -1);
  rb_define_method(SwigClassLog.klass, "is_debug_output_enabled", VALUEFUNC(_wrap_Log_is_debug_output_enabled), -1);
  rb_define_method(SwigClassLog.klass, "is_file_output_suppressed", VALUEFUNC(_wrap_Log_is_file_output_suppressed), -1);
  rb_define_method(SwigClassLog.klass, "is_time_stamp_enabled", VALUEFUNC(_wrap_Log_is_time_stamp_enabled), -1);
  rb_define_method(SwigClassLog.klass, "log_message", VALUEFUNC(_wrap_Log_log_message), -1);
  rb_define_method(SwigClassLog.klass, "stream", VALUEFUNC(_wrap_Log_stream), -1);
  rb_define_method(SwigClassLog.klass, "set_debug_output_enabled", VALUEFUNC(_wrap_Log_set_debug_output_enabled), -1);
  rb_define_method(SwigClassLog.klass, "set_log_detail", VALUEFUNC(_wrap_Log_set_log_detail), -1);
  rb_define_method(SwigClassLog.klass, "set_time_stamp_enabled", VALUEFUNC(_wrap_Log_set_time_stamp_enabled), -1);
  rb_define_method(SwigClassLog.klass, "get_log_detail", VALUEFUNC(_wrap_Log_get_log_detail), -1);
  rb_define_method(SwigClassLog.klass, "add_listener", VALUEFUNC(_wrap_Log_add_listener), -1);
  rb_define_method(SwigClassLog.klass, "remove_listener", VALUEFUNC(_wrap_Log_remove_listener), -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, "create_log", VALUEFUNC(_wrap_LogManager_create_log), -1);
  rb_define_method(SwigClassLogManager.klass, "get_log", VALUEFUNC(_wrap_LogManager_get_log), -1);
  rb_define_method(SwigClassLogManager.klass, "get_default_log", VALUEFUNC(_wrap_LogManager_get_default_log), -1);
  rb_define_method(SwigClassLogManager.klass, "destroy_log", VALUEFUNC(_wrap_LogManager_destroy_log), -1);
  rb_define_method(SwigClassLogManager.klass, "set_default_log", VALUEFUNC(_wrap_LogManager_set_default_log), -1);
  rb_define_method(SwigClassLogManager.klass, "log_message", VALUEFUNC(_wrap_LogManager_log_message), -1);
  rb_define_method(SwigClassLogManager.klass, "stream", VALUEFUNC(_wrap_LogManager_stream), -1);
  rb_define_method(SwigClassLogManager.klass, "set_log_detail", VALUEFUNC(_wrap_LogManager_set_log_detail), -1);
  rb_define_singleton_method(SwigClassLogManager.klass, "get_singleton", VALUEFUNC(_wrap_LogManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassLogManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_LogManager_get_singleton_ptr), -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, "to_string", VALUEFUNC(_wrap_DriverVersion_to_string), -1);
  rb_define_method(SwigClassDriverVersion.klass, "from_string", VALUEFUNC(_wrap_DriverVersion_from_string), -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, "calculate_size", VALUEFUNC(_wrap_RenderSystemCapabilities_calculate_size), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_driver_version", VALUEFUNC(_wrap_RenderSystemCapabilities_set_driver_version), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "parse_driver_version_from_string", VALUEFUNC(_wrap_RenderSystemCapabilities_parse_driver_version_from_string), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_driver_version", VALUEFUNC(_wrap_RenderSystemCapabilities_get_driver_version), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_vendor", VALUEFUNC(_wrap_RenderSystemCapabilities_get_vendor), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_vendor", VALUEFUNC(_wrap_RenderSystemCapabilities_set_vendor), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "parse_vendor_from_string", VALUEFUNC(_wrap_RenderSystemCapabilities_parse_vendor_from_string), -1);
  rb_define_singleton_method(SwigClassRenderSystemCapabilities.klass, "vendor_from_string", VALUEFUNC(_wrap_RenderSystemCapabilities_vendor_from_string), -1);
  rb_define_singleton_method(SwigClassRenderSystemCapabilities.klass, "vendor_to_string", VALUEFUNC(_wrap_RenderSystemCapabilities_vendor_to_string), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "is_driver_older_than_version", VALUEFUNC(_wrap_RenderSystemCapabilities_is_driver_older_than_version), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_num_world_matrices", VALUEFUNC(_wrap_RenderSystemCapabilities_set_num_world_matrices), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_num_texture_units", VALUEFUNC(_wrap_RenderSystemCapabilities_set_num_texture_units), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_stencil_buffer_bit_depth", VALUEFUNC(_wrap_RenderSystemCapabilities_set_stencil_buffer_bit_depth), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_num_vertex_blend_matrices", VALUEFUNC(_wrap_RenderSystemCapabilities_set_num_vertex_blend_matrices), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_num_multi_render_targets", VALUEFUNC(_wrap_RenderSystemCapabilities_set_num_multi_render_targets), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_num_world_matrices", VALUEFUNC(_wrap_RenderSystemCapabilities_get_num_world_matrices), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_num_texture_units", VALUEFUNC(_wrap_RenderSystemCapabilities_get_num_texture_units), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_stencil_buffer_bit_depth", VALUEFUNC(_wrap_RenderSystemCapabilities_get_stencil_buffer_bit_depth), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_num_vertex_blend_matrices", VALUEFUNC(_wrap_RenderSystemCapabilities_get_num_vertex_blend_matrices), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_num_multi_render_targets", VALUEFUNC(_wrap_RenderSystemCapabilities_get_num_multi_render_targets), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "is_capability_render_system_specific", VALUEFUNC(_wrap_RenderSystemCapabilities_is_capability_render_system_specific), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_capability", VALUEFUNC(_wrap_RenderSystemCapabilities_set_capability), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "unset_capability", VALUEFUNC(_wrap_RenderSystemCapabilities_unset_capability), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "has_capability", VALUEFUNC(_wrap_RenderSystemCapabilities_has_capability), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "add_shader_profile", VALUEFUNC(_wrap_RenderSystemCapabilities_add_shader_profile), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "remove_shader_profile", VALUEFUNC(_wrap_RenderSystemCapabilities_remove_shader_profile), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "is_shader_profile_supported", VALUEFUNC(_wrap_RenderSystemCapabilities_is_shader_profile_supported), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_supported_shader_profiles", VALUEFUNC(_wrap_RenderSystemCapabilities_get_supported_shader_profiles), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_vertex_program_constant_float_count", VALUEFUNC(_wrap_RenderSystemCapabilities_get_vertex_program_constant_float_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_vertex_program_constant_int_count", VALUEFUNC(_wrap_RenderSystemCapabilities_get_vertex_program_constant_int_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_vertex_program_constant_bool_count", VALUEFUNC(_wrap_RenderSystemCapabilities_get_vertex_program_constant_bool_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_geometry_program_constant_float_count", VALUEFUNC(_wrap_RenderSystemCapabilities_get_geometry_program_constant_float_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_geometry_program_constant_int_count", VALUEFUNC(_wrap_RenderSystemCapabilities_get_geometry_program_constant_int_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_geometry_program_constant_bool_count", VALUEFUNC(_wrap_RenderSystemCapabilities_get_geometry_program_constant_bool_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_fragment_program_constant_float_count", VALUEFUNC(_wrap_RenderSystemCapabilities_get_fragment_program_constant_float_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_fragment_program_constant_int_count", VALUEFUNC(_wrap_RenderSystemCapabilities_get_fragment_program_constant_int_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_fragment_program_constant_bool_count", VALUEFUNC(_wrap_RenderSystemCapabilities_get_fragment_program_constant_bool_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_device_name", VALUEFUNC(_wrap_RenderSystemCapabilities_set_device_name), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_device_name", VALUEFUNC(_wrap_RenderSystemCapabilities_get_device_name), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_vertex_program_constant_float_count", VALUEFUNC(_wrap_RenderSystemCapabilities_set_vertex_program_constant_float_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_vertex_program_constant_int_count", VALUEFUNC(_wrap_RenderSystemCapabilities_set_vertex_program_constant_int_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_vertex_program_constant_bool_count", VALUEFUNC(_wrap_RenderSystemCapabilities_set_vertex_program_constant_bool_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_geometry_program_constant_float_count", VALUEFUNC(_wrap_RenderSystemCapabilities_set_geometry_program_constant_float_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_geometry_program_constant_int_count", VALUEFUNC(_wrap_RenderSystemCapabilities_set_geometry_program_constant_int_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_geometry_program_constant_bool_count", VALUEFUNC(_wrap_RenderSystemCapabilities_set_geometry_program_constant_bool_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_fragment_program_constant_float_count", VALUEFUNC(_wrap_RenderSystemCapabilities_set_fragment_program_constant_float_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_fragment_program_constant_int_count", VALUEFUNC(_wrap_RenderSystemCapabilities_set_fragment_program_constant_int_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_fragment_program_constant_bool_count", VALUEFUNC(_wrap_RenderSystemCapabilities_set_fragment_program_constant_bool_count), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_max_point_size", VALUEFUNC(_wrap_RenderSystemCapabilities_set_max_point_size), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_max_point_size", VALUEFUNC(_wrap_RenderSystemCapabilities_get_max_point_size), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_non_pow_2textures_limited", VALUEFUNC(_wrap_RenderSystemCapabilities_set_non_pow_2textures_limited), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_non_pow_2textures_limited", VALUEFUNC(_wrap_RenderSystemCapabilities_get_non_pow_2textures_limited), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_num_vertex_texture_units", VALUEFUNC(_wrap_RenderSystemCapabilities_set_num_vertex_texture_units), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_num_vertex_texture_units", VALUEFUNC(_wrap_RenderSystemCapabilities_get_num_vertex_texture_units), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_vertex_texture_units_shared", VALUEFUNC(_wrap_RenderSystemCapabilities_set_vertex_texture_units_shared), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_vertex_texture_units_shared", VALUEFUNC(_wrap_RenderSystemCapabilities_get_vertex_texture_units_shared), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_geometry_program_num_output_vertices", VALUEFUNC(_wrap_RenderSystemCapabilities_set_geometry_program_num_output_vertices), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_geometry_program_num_output_vertices", VALUEFUNC(_wrap_RenderSystemCapabilities_get_geometry_program_num_output_vertices), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "get_render_system_name", VALUEFUNC(_wrap_RenderSystemCapabilities_get_render_system_name), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_render_system_name", VALUEFUNC(_wrap_RenderSystemCapabilities_set_render_system_name), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "set_category_relevant", VALUEFUNC(_wrap_RenderSystemCapabilities_set_category_relevant), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "is_category_relevant", VALUEFUNC(_wrap_RenderSystemCapabilities_is_category_relevant), -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, "create_or_retrieve", VALUEFUNC(_wrap_TextureManager_create_or_retrieve), -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, "load_image", VALUEFUNC(_wrap_TextureManager_load_image), -1);
  rb_define_method(SwigClassTextureManager.klass, "load_raw_data", VALUEFUNC(_wrap_TextureManager_load_raw_data), -1);
  rb_define_method(SwigClassTextureManager.klass, "create_manual", VALUEFUNC(_wrap_TextureManager_create_manual), -1);
  rb_define_method(SwigClassTextureManager.klass, "set_preferred_integer_bit_depth", VALUEFUNC(_wrap_TextureManager_set_preferred_integer_bit_depth), -1);
  rb_define_method(SwigClassTextureManager.klass, "get_preferred_integer_bit_depth", VALUEFUNC(_wrap_TextureManager_get_preferred_integer_bit_depth), -1);
  rb_define_method(SwigClassTextureManager.klass, "set_preferred_float_bit_depth", VALUEFUNC(_wrap_TextureManager_set_preferred_float_bit_depth), -1);
  rb_define_method(SwigClassTextureManager.klass, "get_preferred_float_bit_depth", VALUEFUNC(_wrap_TextureManager_get_preferred_float_bit_depth), -1);
  rb_define_method(SwigClassTextureManager.klass, "set_preferred_bit_depths", VALUEFUNC(_wrap_TextureManager_set_preferred_bit_depths), -1);
  rb_define_method(SwigClassTextureManager.klass, "is_format_supported", VALUEFUNC(_wrap_TextureManager_is_format_supported), -1);
  rb_define_method(SwigClassTextureManager.klass, "is_equivalent_format_supported", VALUEFUNC(_wrap_TextureManager_is_equivalent_format_supported), -1);
  rb_define_method(SwigClassTextureManager.klass, "get_native_format", VALUEFUNC(_wrap_TextureManager_get_native_format), -1);
  rb_define_method(SwigClassTextureManager.klass, "is_hardware_filtering_supported", VALUEFUNC(_wrap_TextureManager_is_hardware_filtering_supported), -1);
  rb_define_method(SwigClassTextureManager.klass, "set_default_num_mipmaps", VALUEFUNC(_wrap_TextureManager_set_default_num_mipmaps), -1);
  rb_define_method(SwigClassTextureManager.klass, "get_default_num_mipmaps", VALUEFUNC(_wrap_TextureManager_get_default_num_mipmaps), -1);
  rb_define_singleton_method(SwigClassTextureManager.klass, "get_singleton", VALUEFUNC(_wrap_TextureManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassTextureManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_TextureManager_get_singleton_ptr), -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, "_update_dimensions", VALUEFUNC(_wrap_Viewport__update_dimensions), -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, "get_target", VALUEFUNC(_wrap_Viewport_get_target), -1);
  rb_define_method(SwigClassViewport.klass, "get_camera", VALUEFUNC(_wrap_Viewport_get_camera), -1);
  rb_define_method(SwigClassViewport.klass, "set_camera", VALUEFUNC(_wrap_Viewport_set_camera), -1);
  rb_define_method(SwigClassViewport.klass, "get_zorder", VALUEFUNC(_wrap_Viewport_get_zorder), -1);
  rb_define_method(SwigClassViewport.klass, "get_left", VALUEFUNC(_wrap_Viewport_get_left), -1);
  rb_define_method(SwigClassViewport.klass, "get_top", VALUEFUNC(_wrap_Viewport_get_top), -1);
  rb_define_method(SwigClassViewport.klass, "get_width", VALUEFUNC(_wrap_Viewport_get_width), -1);
  rb_define_method(SwigClassViewport.klass, "get_height", VALUEFUNC(_wrap_Viewport_get_height), -1);
  rb_define_method(SwigClassViewport.klass, "get_actual_left", VALUEFUNC(_wrap_Viewport_get_actual_left), -1);
  rb_define_method(SwigClassViewport.klass, "get_actual_top", VALUEFUNC(_wrap_Viewport_get_actual_top), -1);
  rb_define_method(SwigClassViewport.klass, "get_actual_width", VALUEFUNC(_wrap_Viewport_get_actual_width), -1);
  rb_define_method(SwigClassViewport.klass, "get_actual_height", VALUEFUNC(_wrap_Viewport_get_actual_height), -1);
  rb_define_method(SwigClassViewport.klass, "set_dimensions", VALUEFUNC(_wrap_Viewport_set_dimensions), -1);
  rb_define_method(SwigClassViewport.klass, "set_orientation_mode", VALUEFUNC(_wrap_Viewport_set_orientation_mode), -1);
  rb_define_method(SwigClassViewport.klass, "get_orientation_mode", VALUEFUNC(_wrap_Viewport_get_orientation_mode), -1);
  rb_define_singleton_method(SwigClassViewport.klass, "set_default_orientation_mode", VALUEFUNC(_wrap_Viewport_set_default_orientation_mode), -1);
  rb_define_singleton_method(SwigClassViewport.klass, "get_default_orientation_mode", VALUEFUNC(_wrap_Viewport_get_default_orientation_mode), -1);
  rb_define_method(SwigClassViewport.klass, "set_background_colour", VALUEFUNC(_wrap_Viewport_set_background_colour), -1);
  rb_define_method(SwigClassViewport.klass, "get_background_colour", VALUEFUNC(_wrap_Viewport_get_background_colour), -1);
  rb_define_method(SwigClassViewport.klass, "set_depth_clear", VALUEFUNC(_wrap_Viewport_set_depth_clear), -1);
  rb_define_method(SwigClassViewport.klass, "get_depth_clear", VALUEFUNC(_wrap_Viewport_get_depth_clear), -1);
  rb_define_method(SwigClassViewport.klass, "set_clear_every_frame", VALUEFUNC(_wrap_Viewport_set_clear_every_frame), -1);
  rb_define_method(SwigClassViewport.klass, "get_clear_every_frame", VALUEFUNC(_wrap_Viewport_get_clear_every_frame), -1);
  rb_define_method(SwigClassViewport.klass, "get_clear_buffers", VALUEFUNC(_wrap_Viewport_get_clear_buffers), -1);
  rb_define_method(SwigClassViewport.klass, "set_auto_updated", VALUEFUNC(_wrap_Viewport_set_auto_updated), -1);
  rb_define_method(SwigClassViewport.klass, "is_auto_updated", VALUEFUNC(_wrap_Viewport_is_auto_updated), -1);
  rb_define_method(SwigClassViewport.klass, "set_material_scheme", VALUEFUNC(_wrap_Viewport_set_material_scheme), -1);
  rb_define_method(SwigClassViewport.klass, "get_material_scheme", VALUEFUNC(_wrap_Viewport_get_material_scheme), -1);
  rb_define_method(SwigClassViewport.klass, "get_actual_dimensions", VALUEFUNC(_wrap_Viewport_get_actual_dimensions), -1);
  rb_define_method(SwigClassViewport.klass, "_is_updated", VALUEFUNC(_wrap_Viewport__is_updated), -1);
  rb_define_method(SwigClassViewport.klass, "_clear_updated_flag", VALUEFUNC(_wrap_Viewport__clear_updated_flag), -1);
  rb_define_method(SwigClassViewport.klass, "_get_num_rendered_faces", VALUEFUNC(_wrap_Viewport__get_num_rendered_faces), -1);
  rb_define_method(SwigClassViewport.klass, "_get_num_rendered_batches", VALUEFUNC(_wrap_Viewport__get_num_rendered_batches), -1);
  rb_define_method(SwigClassViewport.klass, "set_overlays_enabled", VALUEFUNC(_wrap_Viewport_set_overlays_enabled), -1);
  rb_define_method(SwigClassViewport.klass, "get_overlays_enabled", VALUEFUNC(_wrap_Viewport_get_overlays_enabled), -1);
  rb_define_method(SwigClassViewport.klass, "set_skies_enabled", VALUEFUNC(_wrap_Viewport_set_skies_enabled), -1);
  rb_define_method(SwigClassViewport.klass, "get_skies_enabled", VALUEFUNC(_wrap_Viewport_get_skies_enabled), -1);
  rb_define_method(SwigClassViewport.klass, "set_shadows_enabled", VALUEFUNC(_wrap_Viewport_set_shadows_enabled), -1);
  rb_define_method(SwigClassViewport.klass, "get_shadows_enabled", VALUEFUNC(_wrap_Viewport_get_shadows_enabled), -1);
  rb_define_method(SwigClassViewport.klass, "set_visibility_mask", VALUEFUNC(_wrap_Viewport_set_visibility_mask), -1);
  rb_define_method(SwigClassViewport.klass, "get_visibility_mask", VALUEFUNC(_wrap_Viewport_get_visibility_mask), -1);
  rb_define_method(SwigClassViewport.klass, "set_render_queue_invocation_sequence_name", VALUEFUNC(_wrap_Viewport_set_render_queue_invocation_sequence_name), -1);
  rb_define_method(SwigClassViewport.klass, "get_render_queue_invocation_sequence_name", VALUEFUNC(_wrap_Viewport_get_render_queue_invocation_sequence_name), -1);
  rb_define_method(SwigClassViewport.klass, "_get_render_queue_invocation_sequence", VALUEFUNC(_wrap_Viewport__get_render_queue_invocation_sequence), -1);
  rb_define_method(SwigClassViewport.klass, "point_oriented_to_screen", VALUEFUNC(_wrap_Viewport_point_oriented_to_screen), -1);
  rb_define_method(SwigClassViewport.klass, "add_listener", VALUEFUNC(_wrap_Viewport_add_listener), -1);
  rb_define_method(SwigClassViewport.klass, "remove_listener", VALUEFUNC(_wrap_Viewport_remove_listener), -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, "get_name", VALUEFUNC(_wrap_RenderTarget_get_name), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_metrics", VALUEFUNC(_wrap_RenderTarget_get_metrics), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_width", VALUEFUNC(_wrap_RenderTarget_get_width), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_height", VALUEFUNC(_wrap_RenderTarget_get_height), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_colour_depth", VALUEFUNC(_wrap_RenderTarget_get_colour_depth), -1);
  rb_define_method(SwigClassRenderTarget.klass, "set_depth_buffer_pool", VALUEFUNC(_wrap_RenderTarget_set_depth_buffer_pool), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_depth_buffer_pool", VALUEFUNC(_wrap_RenderTarget_get_depth_buffer_pool), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_depth_buffer", VALUEFUNC(_wrap_RenderTarget_get_depth_buffer), -1);
  rb_define_method(SwigClassRenderTarget.klass, "attach_depth_buffer", VALUEFUNC(_wrap_RenderTarget_attach_depth_buffer), -1);
  rb_define_method(SwigClassRenderTarget.klass, "detach_depth_buffer", VALUEFUNC(_wrap_RenderTarget_detach_depth_buffer), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_detach_depth_buffer", VALUEFUNC(_wrap_RenderTarget__detach_depth_buffer), -1);
  rb_define_method(SwigClassRenderTarget.klass, "update", VALUEFUNC(_wrap_RenderTarget_update), -1);
  rb_define_method(SwigClassRenderTarget.klass, "swap_buffers", VALUEFUNC(_wrap_RenderTarget_swap_buffers), -1);
  rb_define_method(SwigClassRenderTarget.klass, "add_viewport", VALUEFUNC(_wrap_RenderTarget_add_viewport), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_num_viewports", VALUEFUNC(_wrap_RenderTarget_get_num_viewports), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_viewport", VALUEFUNC(_wrap_RenderTarget_get_viewport), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_viewport_by_zorder", VALUEFUNC(_wrap_RenderTarget_get_viewport_by_zorder), -1);
  rb_define_method(SwigClassRenderTarget.klass, "has_viewport_with_zorder", VALUEFUNC(_wrap_RenderTarget_has_viewport_with_zorder), -1);
  rb_define_method(SwigClassRenderTarget.klass, "remove_viewport", VALUEFUNC(_wrap_RenderTarget_remove_viewport), -1);
  rb_define_method(SwigClassRenderTarget.klass, "remove_all_viewports", VALUEFUNC(_wrap_RenderTarget_remove_all_viewports), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_statistics", VALUEFUNC(_wrap_RenderTarget_get_statistics), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_last_fps", VALUEFUNC(_wrap_RenderTarget_get_last_fps), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_average_fps", VALUEFUNC(_wrap_RenderTarget_get_average_fps), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_best_fps", VALUEFUNC(_wrap_RenderTarget_get_best_fps), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_worst_fps", VALUEFUNC(_wrap_RenderTarget_get_worst_fps), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_best_frame_time", VALUEFUNC(_wrap_RenderTarget_get_best_frame_time), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_worst_frame_time", VALUEFUNC(_wrap_RenderTarget_get_worst_frame_time), -1);
  rb_define_method(SwigClassRenderTarget.klass, "reset_statistics", VALUEFUNC(_wrap_RenderTarget_reset_statistics), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_custom_attribute", VALUEFUNC(_wrap_RenderTarget_get_custom_attribute), -1);
  rb_define_method(SwigClassRenderTarget.klass, "add_listener", VALUEFUNC(_wrap_RenderTarget_add_listener), -1);
  rb_define_method(SwigClassRenderTarget.klass, "remove_listener", VALUEFUNC(_wrap_RenderTarget_remove_listener), -1);
  rb_define_method(SwigClassRenderTarget.klass, "remove_all_listeners", VALUEFUNC(_wrap_RenderTarget_remove_all_listeners), -1);
  rb_define_method(SwigClassRenderTarget.klass, "set_priority", VALUEFUNC(_wrap_RenderTarget_set_priority), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_priority", VALUEFUNC(_wrap_RenderTarget_get_priority), -1);
  rb_define_method(SwigClassRenderTarget.klass, "is_active", VALUEFUNC(_wrap_RenderTarget_is_active), -1);
  rb_define_method(SwigClassRenderTarget.klass, "set_active", VALUEFUNC(_wrap_RenderTarget_set_active), -1);
  rb_define_method(SwigClassRenderTarget.klass, "set_auto_updated", VALUEFUNC(_wrap_RenderTarget_set_auto_updated), -1);
  rb_define_method(SwigClassRenderTarget.klass, "is_auto_updated", VALUEFUNC(_wrap_RenderTarget_is_auto_updated), -1);
  rb_define_method(SwigClassRenderTarget.klass, "copy_contents_to_memory", VALUEFUNC(_wrap_RenderTarget_copy_contents_to_memory), -1);
  rb_define_method(SwigClassRenderTarget.klass, "suggest_pixel_format", VALUEFUNC(_wrap_RenderTarget_suggest_pixel_format), -1);
  rb_define_method(SwigClassRenderTarget.klass, "write_contents_to_file", VALUEFUNC(_wrap_RenderTarget_write_contents_to_file), -1);
  rb_define_method(SwigClassRenderTarget.klass, "write_contents_to_timestamped_file", VALUEFUNC(_wrap_RenderTarget_write_contents_to_timestamped_file), -1);
  rb_define_method(SwigClassRenderTarget.klass, "requires_texture_flipping", VALUEFUNC(_wrap_RenderTarget_requires_texture_flipping), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_triangle_count", VALUEFUNC(_wrap_RenderTarget_get_triangle_count), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_batch_count", VALUEFUNC(_wrap_RenderTarget_get_batch_count), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_notify_camera_removed", VALUEFUNC(_wrap_RenderTarget__notify_camera_removed), -1);
  rb_define_method(SwigClassRenderTarget.klass, "is_primary", VALUEFUNC(_wrap_RenderTarget_is_primary), -1);
  rb_define_method(SwigClassRenderTarget.klass, "is_hardware_gamma_enabled", VALUEFUNC(_wrap_RenderTarget_is_hardware_gamma_enabled), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_fsaa", VALUEFUNC(_wrap_RenderTarget_get_fsaa), -1);
  rb_define_method(SwigClassRenderTarget.klass, "get_fsaahint", VALUEFUNC(_wrap_RenderTarget_get_fsaahint), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_get_impl", VALUEFUNC(_wrap_RenderTarget__get_impl), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_begin_update", VALUEFUNC(_wrap_RenderTarget__begin_update), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_update_viewport", VALUEFUNC(_wrap_RenderTarget__update_viewport), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_update_auto_updated_viewports", VALUEFUNC(_wrap_RenderTarget__update_auto_updated_viewports), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_end_update", VALUEFUNC(_wrap_RenderTarget__end_update), -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, "copy_contents_to_memory", VALUEFUNC(_wrap_RenderTexture_copy_contents_to_memory), -1);
  rb_define_method(SwigClassRenderTexture.klass, "suggest_pixel_format", VALUEFUNC(_wrap_RenderTexture_suggest_pixel_format), -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, "bind_surface", VALUEFUNC(_wrap_MultiRenderTarget_bind_surface), -1);
  rb_define_method(SwigClassMultiRenderTarget.klass, "unbind_surface", VALUEFUNC(_wrap_MultiRenderTarget_unbind_surface), -1);
  rb_define_method(SwigClassMultiRenderTarget.klass, "copy_contents_to_memory", VALUEFUNC(_wrap_MultiRenderTarget_copy_contents_to_memory), -1);
  rb_define_method(SwigClassMultiRenderTarget.klass, "suggest_pixel_format", VALUEFUNC(_wrap_MultiRenderTarget_suggest_pixel_format), -1);
  rb_define_method(SwigClassMultiRenderTarget.klass, "get_bound_surface_list", VALUEFUNC(_wrap_MultiRenderTarget_get_bound_surface_list), -1);
  rb_define_method(SwigClassMultiRenderTarget.klass, "get_bound_surface", VALUEFUNC(_wrap_MultiRenderTarget_get_bound_surface), -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, "frame_started", VALUEFUNC(_wrap_FrameListener_frame_started), -1);
  rb_define_method(SwigClassFrameListener.klass, "frame_rendering_queued", VALUEFUNC(_wrap_FrameListener_frame_rendering_queued), -1);
  rb_define_method(SwigClassFrameListener.klass, "frame_ended", VALUEFUNC(_wrap_FrameListener_frame_ended), -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, "get_name", VALUEFUNC(_wrap_RenderSystem_get_name), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_config_options", VALUEFUNC(_wrap_RenderSystem_get_config_options), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_config_option", VALUEFUNC(_wrap_RenderSystem_set_config_option), -1);
  rb_define_method(SwigClassRenderSystem.klass, "create_hardware_occlusion_query", VALUEFUNC(_wrap_RenderSystem_create_hardware_occlusion_query), -1);
  rb_define_method(SwigClassRenderSystem.klass, "destroy_hardware_occlusion_query", VALUEFUNC(_wrap_RenderSystem_destroy_hardware_occlusion_query), -1);
  rb_define_method(SwigClassRenderSystem.klass, "validate_config_options", VALUEFUNC(_wrap_RenderSystem_validate_config_options), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_initialise", VALUEFUNC(_wrap_RenderSystem__initialise), -1);
  rb_define_method(SwigClassRenderSystem.klass, "create_render_system_capabilities", VALUEFUNC(_wrap_RenderSystem_create_render_system_capabilities), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_mutable_capabilities", VALUEFUNC(_wrap_RenderSystem_get_mutable_capabilities), -1);
  rb_define_method(SwigClassRenderSystem.klass, "use_custom_render_system_capabilities", VALUEFUNC(_wrap_RenderSystem_use_custom_render_system_capabilities), -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, "set_ambient_light", VALUEFUNC(_wrap_RenderSystem_set_ambient_light), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_shading_type", VALUEFUNC(_wrap_RenderSystem_set_shading_type), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_lighting_enabled", VALUEFUNC(_wrap_RenderSystem_set_lighting_enabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_wbuffer_enabled", VALUEFUNC(_wrap_RenderSystem_set_wbuffer_enabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_wbuffer_enabled", VALUEFUNC(_wrap_RenderSystem_get_wbuffer_enabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_create_render_window", VALUEFUNC(_wrap_RenderSystem__create_render_window), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_create_render_windows", VALUEFUNC(_wrap_RenderSystem__create_render_windows), -1);
  rb_define_method(SwigClassRenderSystem.klass, "create_multi_render_target", VALUEFUNC(_wrap_RenderSystem_create_multi_render_target), -1);
  rb_define_method(SwigClassRenderSystem.klass, "destroy_render_window", VALUEFUNC(_wrap_RenderSystem_destroy_render_window), -1);
  rb_define_method(SwigClassRenderSystem.klass, "destroy_render_texture", VALUEFUNC(_wrap_RenderSystem_destroy_render_texture), -1);
  rb_define_method(SwigClassRenderSystem.klass, "destroy_render_target", VALUEFUNC(_wrap_RenderSystem_destroy_render_target), -1);
  rb_define_method(SwigClassRenderSystem.klass, "attach_render_target", VALUEFUNC(_wrap_RenderSystem_attach_render_target), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_render_target", VALUEFUNC(_wrap_RenderSystem_get_render_target), -1);
  rb_define_method(SwigClassRenderSystem.klass, "detach_render_target", VALUEFUNC(_wrap_RenderSystem_detach_render_target), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_render_target_iterator", VALUEFUNC(_wrap_RenderSystem_get_render_target_iterator), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_error_description", VALUEFUNC(_wrap_RenderSystem_get_error_description), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_wait_for_vertical_blank", VALUEFUNC(_wrap_RenderSystem_set_wait_for_vertical_blank), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_wait_for_vertical_blank", VALUEFUNC(_wrap_RenderSystem_get_wait_for_vertical_blank), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_global_instance_vertex_buffer", VALUEFUNC(_wrap_RenderSystem_get_global_instance_vertex_buffer), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_global_instance_vertex_buffer", VALUEFUNC(_wrap_RenderSystem_set_global_instance_vertex_buffer), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_global_instance_vertex_buffer_vertex_declaration", VALUEFUNC(_wrap_RenderSystem_get_global_instance_vertex_buffer_vertex_declaration), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_global_instance_vertex_buffer_vertex_declaration", VALUEFUNC(_wrap_RenderSystem_set_global_instance_vertex_buffer_vertex_declaration), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_global_number_of_instances", VALUEFUNC(_wrap_RenderSystem_get_global_number_of_instances), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_global_number_of_instances", VALUEFUNC(_wrap_RenderSystem_set_global_number_of_instances), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_fixed_pipeline_enabled", VALUEFUNC(_wrap_RenderSystem_set_fixed_pipeline_enabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_fixed_pipeline_enabled", VALUEFUNC(_wrap_RenderSystem_get_fixed_pipeline_enabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_depth_buffer_for", VALUEFUNC(_wrap_RenderSystem_set_depth_buffer_for), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_use_lights", VALUEFUNC(_wrap_RenderSystem__use_lights), -1);
  rb_define_method(SwigClassRenderSystem.klass, "are_fixed_function_lights_in_view_space", VALUEFUNC(_wrap_RenderSystem_are_fixed_function_lights_in_view_space), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_world_matrix", VALUEFUNC(_wrap_RenderSystem__set_world_matrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_world_matrices", VALUEFUNC(_wrap_RenderSystem__set_world_matrices), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_view_matrix", VALUEFUNC(_wrap_RenderSystem__set_view_matrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_projection_matrix", VALUEFUNC(_wrap_RenderSystem__set_projection_matrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_texture_unit_settings", VALUEFUNC(_wrap_RenderSystem__set_texture_unit_settings), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_disable_texture_unit", VALUEFUNC(_wrap_RenderSystem__disable_texture_unit), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_disable_texture_units_from", VALUEFUNC(_wrap_RenderSystem__disable_texture_units_from), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_surface_params", VALUEFUNC(_wrap_RenderSystem__set_surface_params), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_point_sprites_enabled", VALUEFUNC(_wrap_RenderSystem__set_point_sprites_enabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_point_parameters", VALUEFUNC(_wrap_RenderSystem__set_point_parameters), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_texture", VALUEFUNC(_wrap_RenderSystem__set_texture), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_vertex_texture", VALUEFUNC(_wrap_RenderSystem__set_vertex_texture), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_texture_coord_set", VALUEFUNC(_wrap_RenderSystem__set_texture_coord_set), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_texture_coord_calculation", VALUEFUNC(_wrap_RenderSystem__set_texture_coord_calculation), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_texture_blend_mode", VALUEFUNC(_wrap_RenderSystem__set_texture_blend_mode), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_texture_unit_filtering", VALUEFUNC(_wrap_RenderSystem__set_texture_unit_filtering), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_texture_layer_anisotropy", VALUEFUNC(_wrap_RenderSystem__set_texture_layer_anisotropy), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_texture_addressing_mode", VALUEFUNC(_wrap_RenderSystem__set_texture_addressing_mode), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_texture_border_colour", VALUEFUNC(_wrap_RenderSystem__set_texture_border_colour), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_texture_mipmap_bias", VALUEFUNC(_wrap_RenderSystem__set_texture_mipmap_bias), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_texture_matrix", VALUEFUNC(_wrap_RenderSystem__set_texture_matrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_scene_blending", VALUEFUNC(_wrap_RenderSystem__set_scene_blending), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_separate_scene_blending", VALUEFUNC(_wrap_RenderSystem__set_separate_scene_blending), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_alpha_reject_settings", VALUEFUNC(_wrap_RenderSystem__set_alpha_reject_settings), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_texture_projection_relative_to", VALUEFUNC(_wrap_RenderSystem__set_texture_projection_relative_to), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_create_depth_buffer_for", VALUEFUNC(_wrap_RenderSystem__create_depth_buffer_for), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_cleanup_depth_buffers", VALUEFUNC(_wrap_RenderSystem__cleanup_depth_buffers), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_begin_frame", VALUEFUNC(_wrap_RenderSystem__begin_frame), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_pause_frame", VALUEFUNC(_wrap_RenderSystem__pause_frame), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_resume_frame", VALUEFUNC(_wrap_RenderSystem__resume_frame), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_end_frame", VALUEFUNC(_wrap_RenderSystem__end_frame), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_viewport", VALUEFUNC(_wrap_RenderSystem__set_viewport), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_get_viewport", VALUEFUNC(_wrap_RenderSystem__get_viewport), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_culling_mode", VALUEFUNC(_wrap_RenderSystem__set_culling_mode), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_get_culling_mode", VALUEFUNC(_wrap_RenderSystem__get_culling_mode), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_depth_buffer_params", VALUEFUNC(_wrap_RenderSystem__set_depth_buffer_params), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_depth_buffer_check_enabled", VALUEFUNC(_wrap_RenderSystem__set_depth_buffer_check_enabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_depth_buffer_write_enabled", VALUEFUNC(_wrap_RenderSystem__set_depth_buffer_write_enabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_depth_buffer_function", VALUEFUNC(_wrap_RenderSystem__set_depth_buffer_function), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_colour_buffer_write_enabled", VALUEFUNC(_wrap_RenderSystem__set_colour_buffer_write_enabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_depth_bias", VALUEFUNC(_wrap_RenderSystem__set_depth_bias), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_fog", VALUEFUNC(_wrap_RenderSystem__set_fog), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_begin_geometry_count", VALUEFUNC(_wrap_RenderSystem__begin_geometry_count), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_get_face_count", VALUEFUNC(_wrap_RenderSystem__get_face_count), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_get_batch_count", VALUEFUNC(_wrap_RenderSystem__get_batch_count), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_get_vertex_count", VALUEFUNC(_wrap_RenderSystem__get_vertex_count), -1);
  rb_define_method(SwigClassRenderSystem.klass, "convert_colour_value", VALUEFUNC(_wrap_RenderSystem_convert_colour_value), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_colour_vertex_element_type", VALUEFUNC(_wrap_RenderSystem_get_colour_vertex_element_type), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_convert_projection_matrix", VALUEFUNC(_wrap_RenderSystem__convert_projection_matrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_make_projection_matrix", VALUEFUNC(_wrap_RenderSystem__make_projection_matrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_make_ortho_matrix", VALUEFUNC(_wrap_RenderSystem__make_ortho_matrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_apply_oblique_depth_projection", VALUEFUNC(_wrap_RenderSystem__apply_oblique_depth_projection), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_polygon_mode", VALUEFUNC(_wrap_RenderSystem__set_polygon_mode), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_stencil_check_enabled", VALUEFUNC(_wrap_RenderSystem_set_stencil_check_enabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_stencil_buffer_params", VALUEFUNC(_wrap_RenderSystem_set_stencil_buffer_params), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_vertex_declaration", VALUEFUNC(_wrap_RenderSystem_set_vertex_declaration), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_vertex_buffer_binding", VALUEFUNC(_wrap_RenderSystem_set_vertex_buffer_binding), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_normalise_normals", VALUEFUNC(_wrap_RenderSystem_set_normalise_normals), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_render", VALUEFUNC(_wrap_RenderSystem__render), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_capabilities", VALUEFUNC(_wrap_RenderSystem_get_capabilities), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_driver_version", VALUEFUNC(_wrap_RenderSystem_get_driver_version), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_get_default_viewport_material_scheme", VALUEFUNC(_wrap_RenderSystem__get_default_viewport_material_scheme), -1);
  rb_define_method(SwigClassRenderSystem.klass, "bind_gpu_program", VALUEFUNC(_wrap_RenderSystem_bind_gpu_program), -1);
  rb_define_method(SwigClassRenderSystem.klass, "bind_gpu_program_parameters", VALUEFUNC(_wrap_RenderSystem_bind_gpu_program_parameters), -1);
  rb_define_method(SwigClassRenderSystem.klass, "bind_gpu_program_pass_iteration_parameters", VALUEFUNC(_wrap_RenderSystem_bind_gpu_program_pass_iteration_parameters), -1);
  rb_define_method(SwigClassRenderSystem.klass, "unbind_gpu_program", VALUEFUNC(_wrap_RenderSystem_unbind_gpu_program), -1);
  rb_define_method(SwigClassRenderSystem.klass, "is_gpu_program_bound", VALUEFUNC(_wrap_RenderSystem_is_gpu_program_bound), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_clip_planes", VALUEFUNC(_wrap_RenderSystem_set_clip_planes), -1);
  rb_define_method(SwigClassRenderSystem.klass, "add_clip_plane", VALUEFUNC(_wrap_RenderSystem_add_clip_plane), -1);
  rb_define_method(SwigClassRenderSystem.klass, "reset_clip_planes", VALUEFUNC(_wrap_RenderSystem_reset_clip_planes), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_init_render_targets", VALUEFUNC(_wrap_RenderSystem__init_render_targets), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_notify_camera_removed", VALUEFUNC(_wrap_RenderSystem__notify_camera_removed), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_update_all_render_targets", VALUEFUNC(_wrap_RenderSystem__update_all_render_targets), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_swap_all_render_target_buffers", VALUEFUNC(_wrap_RenderSystem__swap_all_render_target_buffers), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_invert_vertex_winding", VALUEFUNC(_wrap_RenderSystem_set_invert_vertex_winding), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_invert_vertex_winding", VALUEFUNC(_wrap_RenderSystem_get_invert_vertex_winding), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_scissor_test", VALUEFUNC(_wrap_RenderSystem_set_scissor_test), -1);
  rb_define_method(SwigClassRenderSystem.klass, "clear_frame_buffer", VALUEFUNC(_wrap_RenderSystem_clear_frame_buffer), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_horizontal_texel_offset", VALUEFUNC(_wrap_RenderSystem_get_horizontal_texel_offset), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_vertical_texel_offset", VALUEFUNC(_wrap_RenderSystem_get_vertical_texel_offset), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_minimum_depth_input_value", VALUEFUNC(_wrap_RenderSystem_get_minimum_depth_input_value), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_maximum_depth_input_value", VALUEFUNC(_wrap_RenderSystem_get_maximum_depth_input_value), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_current_pass_iteration_count", VALUEFUNC(_wrap_RenderSystem_set_current_pass_iteration_count), -1);
  rb_define_method(SwigClassRenderSystem.klass, "set_derive_depth_bias", VALUEFUNC(_wrap_RenderSystem_set_derive_depth_bias), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_set_render_target", VALUEFUNC(_wrap_RenderSystem__set_render_target), -1);
  rb_define_method(SwigClassRenderSystem.klass, "add_listener", VALUEFUNC(_wrap_RenderSystem_add_listener), -1);
  rb_define_method(SwigClassRenderSystem.klass, "remove_listener", VALUEFUNC(_wrap_RenderSystem_remove_listener), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_render_system_events", VALUEFUNC(_wrap_RenderSystem_get_render_system_events), -1);
  rb_define_method(SwigClassRenderSystem.klass, "pre_extra_threads_started", VALUEFUNC(_wrap_RenderSystem_pre_extra_threads_started), -1);
  rb_define_method(SwigClassRenderSystem.klass, "post_extra_threads_started", VALUEFUNC(_wrap_RenderSystem_post_extra_threads_started), -1);
  rb_define_method(SwigClassRenderSystem.klass, "register_thread", VALUEFUNC(_wrap_RenderSystem_register_thread), -1);
  rb_define_method(SwigClassRenderSystem.klass, "unregister_thread", VALUEFUNC(_wrap_RenderSystem_unregister_thread), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_display_monitor_count", VALUEFUNC(_wrap_RenderSystem_get_display_monitor_count), -1);
  rb_define_method(SwigClassRenderSystem.klass, "begin_profile_event", VALUEFUNC(_wrap_RenderSystem_begin_profile_event), -1);
  rb_define_method(SwigClassRenderSystem.klass, "end_profile_event", VALUEFUNC(_wrap_RenderSystem_end_profile_event), -1);
  rb_define_method(SwigClassRenderSystem.klass, "mark_profile_event", VALUEFUNC(_wrap_RenderSystem_mark_profile_event), -1);
  rb_define_method(SwigClassRenderSystem.klass, "get_config_option_hash", VALUEFUNC(_wrap_RenderSystem_get_config_option_hash), -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, "set_type", VALUEFUNC(_wrap_CompositionPass_set_type), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_type", VALUEFUNC(_wrap_CompositionPass_get_type), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_identifier", VALUEFUNC(_wrap_CompositionPass_set_identifier), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_identifier", VALUEFUNC(_wrap_CompositionPass_get_identifier), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_material", VALUEFUNC(_wrap_CompositionPass_set_material), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_material_name", VALUEFUNC(_wrap_CompositionPass_set_material_name), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_material", VALUEFUNC(_wrap_CompositionPass_get_material), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_first_render_queue", VALUEFUNC(_wrap_CompositionPass_set_first_render_queue), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_first_render_queue", VALUEFUNC(_wrap_CompositionPass_get_first_render_queue), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_last_render_queue", VALUEFUNC(_wrap_CompositionPass_set_last_render_queue), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_last_render_queue", VALUEFUNC(_wrap_CompositionPass_get_last_render_queue), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_material_scheme", VALUEFUNC(_wrap_CompositionPass_set_material_scheme), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_material_scheme", VALUEFUNC(_wrap_CompositionPass_get_material_scheme), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_clear_buffers", VALUEFUNC(_wrap_CompositionPass_set_clear_buffers), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_clear_buffers", VALUEFUNC(_wrap_CompositionPass_get_clear_buffers), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_clear_colour", VALUEFUNC(_wrap_CompositionPass_set_clear_colour), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_clear_colour", VALUEFUNC(_wrap_CompositionPass_get_clear_colour), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_clear_depth", VALUEFUNC(_wrap_CompositionPass_set_clear_depth), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_clear_depth", VALUEFUNC(_wrap_CompositionPass_get_clear_depth), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_clear_stencil", VALUEFUNC(_wrap_CompositionPass_set_clear_stencil), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_clear_stencil", VALUEFUNC(_wrap_CompositionPass_get_clear_stencil), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_stencil_check", VALUEFUNC(_wrap_CompositionPass_set_stencil_check), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_stencil_check", VALUEFUNC(_wrap_CompositionPass_get_stencil_check), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_stencil_func", VALUEFUNC(_wrap_CompositionPass_set_stencil_func), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_stencil_func", VALUEFUNC(_wrap_CompositionPass_get_stencil_func), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_stencil_ref_value", VALUEFUNC(_wrap_CompositionPass_set_stencil_ref_value), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_stencil_ref_value", VALUEFUNC(_wrap_CompositionPass_get_stencil_ref_value), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_stencil_mask", VALUEFUNC(_wrap_CompositionPass_set_stencil_mask), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_stencil_mask", VALUEFUNC(_wrap_CompositionPass_get_stencil_mask), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_stencil_fail_op", VALUEFUNC(_wrap_CompositionPass_set_stencil_fail_op), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_stencil_fail_op", VALUEFUNC(_wrap_CompositionPass_get_stencil_fail_op), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_stencil_depth_fail_op", VALUEFUNC(_wrap_CompositionPass_set_stencil_depth_fail_op), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_stencil_depth_fail_op", VALUEFUNC(_wrap_CompositionPass_get_stencil_depth_fail_op), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_stencil_pass_op", VALUEFUNC(_wrap_CompositionPass_set_stencil_pass_op), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_stencil_pass_op", VALUEFUNC(_wrap_CompositionPass_get_stencil_pass_op), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_stencil_two_sided_operation", VALUEFUNC(_wrap_CompositionPass_set_stencil_two_sided_operation), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_stencil_two_sided_operation", VALUEFUNC(_wrap_CompositionPass_get_stencil_two_sided_operation), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_input", VALUEFUNC(_wrap_CompositionPass_set_input), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_input", VALUEFUNC(_wrap_CompositionPass_get_input), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_num_inputs", VALUEFUNC(_wrap_CompositionPass_get_num_inputs), -1);
  rb_define_method(SwigClassCompositionPass.klass, "clear_all_inputs", VALUEFUNC(_wrap_CompositionPass_clear_all_inputs), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_parent", VALUEFUNC(_wrap_CompositionPass_get_parent), -1);
  rb_define_method(SwigClassCompositionPass.klass, "_is_supported", VALUEFUNC(_wrap_CompositionPass__is_supported), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_quad_corners", VALUEFUNC(_wrap_CompositionPass_set_quad_corners), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_quad_corners", VALUEFUNC(_wrap_CompositionPass_get_quad_corners), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_quad_far_corners", VALUEFUNC(_wrap_CompositionPass_set_quad_far_corners), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_quad_far_corners", VALUEFUNC(_wrap_CompositionPass_get_quad_far_corners), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_quad_far_corners_view_space", VALUEFUNC(_wrap_CompositionPass_get_quad_far_corners_view_space), -1);
  rb_define_method(SwigClassCompositionPass.klass, "set_custom_type", VALUEFUNC(_wrap_CompositionPass_set_custom_type), -1);
  rb_define_method(SwigClassCompositionPass.klass, "get_custom_type", VALUEFUNC(_wrap_CompositionPass_get_custom_type), -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, "set_input_mode", VALUEFUNC(_wrap_CompositionTargetPass_set_input_mode), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "get_input_mode", VALUEFUNC(_wrap_CompositionTargetPass_get_input_mode), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "set_output_name", VALUEFUNC(_wrap_CompositionTargetPass_set_output_name), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "get_output_name", VALUEFUNC(_wrap_CompositionTargetPass_get_output_name), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "set_only_initial", VALUEFUNC(_wrap_CompositionTargetPass_set_only_initial), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "get_only_initial", VALUEFUNC(_wrap_CompositionTargetPass_get_only_initial), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "set_visibility_mask", VALUEFUNC(_wrap_CompositionTargetPass_set_visibility_mask), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "get_visibility_mask", VALUEFUNC(_wrap_CompositionTargetPass_get_visibility_mask), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "set_material_scheme", VALUEFUNC(_wrap_CompositionTargetPass_set_material_scheme), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "get_material_scheme", VALUEFUNC(_wrap_CompositionTargetPass_get_material_scheme), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "set_shadows_enabled", VALUEFUNC(_wrap_CompositionTargetPass_set_shadows_enabled), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "get_shadows_enabled", VALUEFUNC(_wrap_CompositionTargetPass_get_shadows_enabled), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "set_lod_bias", VALUEFUNC(_wrap_CompositionTargetPass_set_lod_bias), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "get_lod_bias", VALUEFUNC(_wrap_CompositionTargetPass_get_lod_bias), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "create_pass", VALUEFUNC(_wrap_CompositionTargetPass_create_pass), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "remove_pass", VALUEFUNC(_wrap_CompositionTargetPass_remove_pass), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "get_pass", VALUEFUNC(_wrap_CompositionTargetPass_get_pass), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "get_num_passes", VALUEFUNC(_wrap_CompositionTargetPass_get_num_passes), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "remove_all_passes", VALUEFUNC(_wrap_CompositionTargetPass_remove_all_passes), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "get_pass_iterator", VALUEFUNC(_wrap_CompositionTargetPass_get_pass_iterator), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "get_parent", VALUEFUNC(_wrap_CompositionTargetPass_get_parent), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "_is_supported", VALUEFUNC(_wrap_CompositionTargetPass__is_supported), -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, "create_texture_definition", VALUEFUNC(_wrap_CompositionTechnique_create_texture_definition), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "remove_texture_definition", VALUEFUNC(_wrap_CompositionTechnique_remove_texture_definition), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "get_texture_definition", VALUEFUNC(_wrap_CompositionTechnique_get_texture_definition), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "get_num_texture_definitions", VALUEFUNC(_wrap_CompositionTechnique_get_num_texture_definitions), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "remove_all_texture_definitions", VALUEFUNC(_wrap_CompositionTechnique_remove_all_texture_definitions), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "get_texture_definition_iterator", VALUEFUNC(_wrap_CompositionTechnique_get_texture_definition_iterator), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "create_target_pass", VALUEFUNC(_wrap_CompositionTechnique_create_target_pass), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "remove_target_pass", VALUEFUNC(_wrap_CompositionTechnique_remove_target_pass), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "get_target_pass", VALUEFUNC(_wrap_CompositionTechnique_get_target_pass), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "get_num_target_passes", VALUEFUNC(_wrap_CompositionTechnique_get_num_target_passes), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "remove_all_target_passes", VALUEFUNC(_wrap_CompositionTechnique_remove_all_target_passes), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "get_target_pass_iterator", VALUEFUNC(_wrap_CompositionTechnique_get_target_pass_iterator), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "get_output_target_pass", VALUEFUNC(_wrap_CompositionTechnique_get_output_target_pass), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "is_supported", VALUEFUNC(_wrap_CompositionTechnique_is_supported), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "set_scheme_name", VALUEFUNC(_wrap_CompositionTechnique_set_scheme_name), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "get_scheme_name", VALUEFUNC(_wrap_CompositionTechnique_get_scheme_name), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "set_compositor_logic_name", VALUEFUNC(_wrap_CompositionTechnique_set_compositor_logic_name), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "get_compositor_logic_name", VALUEFUNC(_wrap_CompositionTechnique_get_compositor_logic_name), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "get_parent", VALUEFUNC(_wrap_CompositionTechnique_get_parent), -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, "create_technique", VALUEFUNC(_wrap_Compositor_create_technique), -1);
  rb_define_method(SwigClassCompositor.klass, "remove_technique", VALUEFUNC(_wrap_Compositor_remove_technique), -1);
  rb_define_method(SwigClassCompositor.klass, "get_technique", VALUEFUNC(_wrap_Compositor_get_technique), -1);
  rb_define_method(SwigClassCompositor.klass, "get_num_techniques", VALUEFUNC(_wrap_Compositor_get_num_techniques), -1);
  rb_define_method(SwigClassCompositor.klass, "remove_all_techniques", VALUEFUNC(_wrap_Compositor_remove_all_techniques), -1);
  rb_define_method(SwigClassCompositor.klass, "get_technique_iterator", VALUEFUNC(_wrap_Compositor_get_technique_iterator), -1);
  rb_define_method(SwigClassCompositor.klass, "get_num_supported_techniques", VALUEFUNC(_wrap_Compositor_get_num_supported_techniques), -1);
  rb_define_method(SwigClassCompositor.klass, "get_supported_technique_iterator", VALUEFUNC(_wrap_Compositor_get_supported_technique_iterator), -1);
  rb_define_method(SwigClassCompositor.klass, "get_supported_technique", VALUEFUNC(_wrap_Compositor_get_supported_technique), -1);
  rb_define_method(SwigClassCompositor.klass, "get_texture_instance_name", VALUEFUNC(_wrap_Compositor_get_texture_instance_name), -1);
  rb_define_method(SwigClassCompositor.klass, "get_texture_instance", VALUEFUNC(_wrap_Compositor_get_texture_instance), -1);
  rb_define_method(SwigClassCompositor.klass, "get_render_target", VALUEFUNC(_wrap_Compositor_get_render_target), -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, "pre_render_target_update", VALUEFUNC(_wrap_RenderTargetListener_pre_render_target_update), -1);
  rb_define_method(SwigClassRenderTargetListener.klass, "post_render_target_update", VALUEFUNC(_wrap_RenderTargetListener_post_render_target_update), -1);
  rb_define_method(SwigClassRenderTargetListener.klass, "pre_viewport_update", VALUEFUNC(_wrap_RenderTargetListener_pre_viewport_update), -1);
  rb_define_method(SwigClassRenderTargetListener.klass, "post_viewport_update", VALUEFUNC(_wrap_RenderTargetListener_post_viewport_update), -1);
  rb_define_method(SwigClassRenderTargetListener.klass, "viewport_added", VALUEFUNC(_wrap_RenderTargetListener_viewport_added), -1);
  rb_define_method(SwigClassRenderTargetListener.klass, "viewport_removed", VALUEFUNC(_wrap_RenderTargetListener_viewport_removed), -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, "pre_render_queues", VALUEFUNC(_wrap_RenderQueueListener_pre_render_queues), -1);
  rb_define_method(SwigClassRenderQueueListener.klass, "post_render_queues", VALUEFUNC(_wrap_RenderQueueListener_post_render_queues), -1);
  rb_define_method(SwigClassRenderQueueListener.klass, "render_queue_started", VALUEFUNC(_wrap_RenderQueueListener_render_queue_started), -1);
  rb_define_method(SwigClassRenderQueueListener.klass, "render_queue_ended", VALUEFUNC(_wrap_RenderQueueListener_render_queue_ended), -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, "set_enabled", VALUEFUNC(_wrap_CompositorInstance_set_enabled), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "get_enabled", VALUEFUNC(_wrap_CompositorInstance_get_enabled), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "set_alive", VALUEFUNC(_wrap_CompositorInstance_set_alive), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "get_alive", VALUEFUNC(_wrap_CompositorInstance_get_alive), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "get_texture_instance_name", VALUEFUNC(_wrap_CompositorInstance_get_texture_instance_name), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "get_texture_instance", VALUEFUNC(_wrap_CompositorInstance_get_texture_instance), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "get_render_target", VALUEFUNC(_wrap_CompositorInstance_get_render_target), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "_compile_target_operations", VALUEFUNC(_wrap_CompositorInstance__compile_target_operations), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "_compile_output_operation", VALUEFUNC(_wrap_CompositorInstance__compile_output_operation), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "get_compositor", VALUEFUNC(_wrap_CompositorInstance_get_compositor), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "get_technique", VALUEFUNC(_wrap_CompositorInstance_get_technique), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "set_technique", VALUEFUNC(_wrap_CompositorInstance_set_technique), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "set_scheme", VALUEFUNC(_wrap_CompositorInstance_set_scheme), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "get_scheme", VALUEFUNC(_wrap_CompositorInstance_get_scheme), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "notify_resized", VALUEFUNC(_wrap_CompositorInstance_notify_resized), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "get_chain", VALUEFUNC(_wrap_CompositorInstance_get_chain), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "add_listener", VALUEFUNC(_wrap_CompositorInstance_add_listener), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "remove_listener", VALUEFUNC(_wrap_CompositorInstance_remove_listener), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "_fire_notify_material_setup", VALUEFUNC(_wrap_CompositorInstance__fire_notify_material_setup), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "_fire_notify_material_render", VALUEFUNC(_wrap_CompositorInstance__fire_notify_material_render), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "_fire_notify_resources_created", VALUEFUNC(_wrap_CompositorInstance__fire_notify_resources_created), -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, "add_compositor", VALUEFUNC(_wrap_CompositorChain_add_compositor), -1);
  rb_define_method(SwigClassCompositorChain.klass, "remove_compositor", VALUEFUNC(_wrap_CompositorChain_remove_compositor), -1);
  rb_define_method(SwigClassCompositorChain.klass, "get_num_compositors", VALUEFUNC(_wrap_CompositorChain_get_num_compositors), -1);
  rb_define_method(SwigClassCompositorChain.klass, "remove_all_compositors", VALUEFUNC(_wrap_CompositorChain_remove_all_compositors), -1);
  rb_define_method(SwigClassCompositorChain.klass, "get_compositor", VALUEFUNC(_wrap_CompositorChain_get_compositor), -1);
  rb_define_method(SwigClassCompositorChain.klass, "_get_original_scene_compositor", VALUEFUNC(_wrap_CompositorChain__get_original_scene_compositor), -1);
  rb_define_method(SwigClassCompositorChain.klass, "get_compositors", VALUEFUNC(_wrap_CompositorChain_get_compositors), -1);
  rb_define_method(SwigClassCompositorChain.klass, "set_compositor_enabled", VALUEFUNC(_wrap_CompositorChain_set_compositor_enabled), -1);
  rb_define_method(SwigClassCompositorChain.klass, "pre_render_target_update", VALUEFUNC(_wrap_CompositorChain_pre_render_target_update), -1);
  rb_define_method(SwigClassCompositorChain.klass, "post_render_target_update", VALUEFUNC(_wrap_CompositorChain_post_render_target_update), -1);
  rb_define_method(SwigClassCompositorChain.klass, "pre_viewport_update", VALUEFUNC(_wrap_CompositorChain_pre_viewport_update), -1);
  rb_define_method(SwigClassCompositorChain.klass, "post_viewport_update", VALUEFUNC(_wrap_CompositorChain_post_viewport_update), -1);
  rb_define_method(SwigClassCompositorChain.klass, "viewport_camera_changed", VALUEFUNC(_wrap_CompositorChain_viewport_camera_changed), -1);
  rb_define_method(SwigClassCompositorChain.klass, "viewport_dimensions_changed", VALUEFUNC(_wrap_CompositorChain_viewport_dimensions_changed), -1);
  rb_define_method(SwigClassCompositorChain.klass, "viewport_destroyed", VALUEFUNC(_wrap_CompositorChain_viewport_destroyed), -1);
  rb_define_method(SwigClassCompositorChain.klass, "_mark_dirty", VALUEFUNC(_wrap_CompositorChain__mark_dirty), -1);
  rb_define_method(SwigClassCompositorChain.klass, "get_viewport", VALUEFUNC(_wrap_CompositorChain_get_viewport), -1);
  rb_define_method(SwigClassCompositorChain.klass, "_remove_instance", VALUEFUNC(_wrap_CompositorChain__remove_instance), -1);
  rb_define_method(SwigClassCompositorChain.klass, "_queued_operation", VALUEFUNC(_wrap_CompositorChain__queued_operation), -1);
  rb_define_method(SwigClassCompositorChain.klass, "_compile", VALUEFUNC(_wrap_CompositorChain__compile), -1);
  rb_define_method(SwigClassCompositorChain.klass, "get_previous_instance", VALUEFUNC(_wrap_CompositorChain_get_previous_instance), -1);
  rb_define_method(SwigClassCompositorChain.klass, "get_next_instance", VALUEFUNC(_wrap_CompositorChain_get_next_instance), -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, "compositor_instance_created", VALUEFUNC(_wrap_CompositorLogic_compositor_instance_created), -1);
  rb_define_method(SwigClassCompositorLogic.klass, "compositor_instance_destroyed", VALUEFUNC(_wrap_CompositorLogic_compositor_instance_destroyed), -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, "set_corners", VALUEFUNC(_wrap_Rectangle2D_set_corners), -1);
  rb_define_method(SwigClassRectangle2D.klass, "set_normals", VALUEFUNC(_wrap_Rectangle2D_set_normals), -1);
  rb_define_method(SwigClassRectangle2D.klass, "set_uvs", VALUEFUNC(_wrap_Rectangle2D_set_uvs), -1);
  rb_define_method(SwigClassRectangle2D.klass, "set_default_uvs", VALUEFUNC(_wrap_Rectangle2D_set_default_uvs), -1);
  rb_define_method(SwigClassRectangle2D.klass, "get_squared_view_depth", VALUEFUNC(_wrap_Rectangle2D_get_squared_view_depth), -1);
  rb_define_method(SwigClassRectangle2D.klass, "get_bounding_radius", VALUEFUNC(_wrap_Rectangle2D_get_bounding_radius), -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, "create_impl", VALUEFUNC(_wrap_CompositorManager_create_impl), -1);
  rb_define_method(SwigClassCompositorManager.klass, "initialise", VALUEFUNC(_wrap_CompositorManager_initialise), -1);
  rb_define_method(SwigClassCompositorManager.klass, "parse_script", VALUEFUNC(_wrap_CompositorManager_parse_script), -1);
  rb_define_method(SwigClassCompositorManager.klass, "get_compositor_chain", VALUEFUNC(_wrap_CompositorManager_get_compositor_chain), -1);
  rb_define_method(SwigClassCompositorManager.klass, "has_compositor_chain", VALUEFUNC(_wrap_CompositorManager_has_compositor_chain), -1);
  rb_define_method(SwigClassCompositorManager.klass, "remove_compositor_chain", VALUEFUNC(_wrap_CompositorManager_remove_compositor_chain), -1);
  rb_define_method(SwigClassCompositorManager.klass, "add_compositor", VALUEFUNC(_wrap_CompositorManager_add_compositor), -1);
  rb_define_method(SwigClassCompositorManager.klass, "remove_compositor", VALUEFUNC(_wrap_CompositorManager_remove_compositor), -1);
  rb_define_method(SwigClassCompositorManager.klass, "set_compositor_enabled", VALUEFUNC(_wrap_CompositorManager_set_compositor_enabled), -1);
  rb_define_method(SwigClassCompositorManager.klass, "_get_textured_rectangle_2d", VALUEFUNC(_wrap_CompositorManager__get_textured_rectangle_2d), -1);
  rb_define_method(SwigClassCompositorManager.klass, "remove_all", VALUEFUNC(_wrap_CompositorManager_remove_all), -1);
  rb_define_method(SwigClassCompositorManager.klass, "_reconstruct_all_compositor_resources", VALUEFUNC(_wrap_CompositorManager__reconstruct_all_compositor_resources), -1);
  rb_define_method(SwigClassCompositorManager.klass, "get_pooled_texture", VALUEFUNC(_wrap_CompositorManager_get_pooled_texture), -1);
  rb_define_method(SwigClassCompositorManager.klass, "free_pooled_textures", VALUEFUNC(_wrap_CompositorManager_free_pooled_textures), -1);
  rb_define_method(SwigClassCompositorManager.klass, "register_compositor_logic", VALUEFUNC(_wrap_CompositorManager_register_compositor_logic), -1);
  rb_define_method(SwigClassCompositorManager.klass, "unregister_compositor_logic", VALUEFUNC(_wrap_CompositorManager_unregister_compositor_logic), -1);
  rb_define_method(SwigClassCompositorManager.klass, "get_compositor_logic", VALUEFUNC(_wrap_CompositorManager_get_compositor_logic), -1);
  rb_define_method(SwigClassCompositorManager.klass, "register_custom_composition_pass", VALUEFUNC(_wrap_CompositorManager_register_custom_composition_pass), -1);
  rb_define_method(SwigClassCompositorManager.klass, "get_custom_composition_pass", VALUEFUNC(_wrap_CompositorManager_get_custom_composition_pass), -1);
  rb_define_singleton_method(SwigClassCompositorManager.klass, "get_singleton", VALUEFUNC(_wrap_CompositorManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassCompositorManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_CompositorManager_get_singleton_ptr), -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, "load_direct", VALUEFUNC(_wrap_ConfigFile_load_direct), -1);
  rb_define_method(SwigClassConfigFile.klass, "load_from_resource_system", VALUEFUNC(_wrap_ConfigFile_load_from_resource_system), -1);
  rb_define_method(SwigClassConfigFile.klass, "get_setting", VALUEFUNC(_wrap_ConfigFile_get_setting), -1);
  rb_define_method(SwigClassConfigFile.klass, "get_multi_setting", VALUEFUNC(_wrap_ConfigFile_get_multi_setting), -1);
  rb_define_method(SwigClassConfigFile.klass, "get_section_iterator", VALUEFUNC(_wrap_ConfigFile_get_section_iterator), -1);
  rb_define_method(SwigClassConfigFile.klass, "get_settings_iterator", VALUEFUNC(_wrap_ConfigFile_get_settings_iterator), -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, "frame_ended", VALUEFUNC(_wrap_FrameTimeControllerValue_frame_ended), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "frame_started", VALUEFUNC(_wrap_FrameTimeControllerValue_frame_started), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "get_value", VALUEFUNC(_wrap_FrameTimeControllerValue_get_value), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "set_value", VALUEFUNC(_wrap_FrameTimeControllerValue_set_value), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "get_time_factor", VALUEFUNC(_wrap_FrameTimeControllerValue_get_time_factor), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "set_time_factor", VALUEFUNC(_wrap_FrameTimeControllerValue_set_time_factor), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "get_frame_delay", VALUEFUNC(_wrap_FrameTimeControllerValue_get_frame_delay), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "set_frame_delay", VALUEFUNC(_wrap_FrameTimeControllerValue_set_frame_delay), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "get_elapsed_time", VALUEFUNC(_wrap_FrameTimeControllerValue_get_elapsed_time), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "set_elapsed_time", VALUEFUNC(_wrap_FrameTimeControllerValue_set_elapsed_time), -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, "get_value", VALUEFUNC(_wrap_TextureFrameControllerValue_get_value), -1);
  rb_define_method(SwigClassTextureFrameControllerValue.klass, "set_value", VALUEFUNC(_wrap_TextureFrameControllerValue_set_value), -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, "get_value", VALUEFUNC(_wrap_TexCoordModifierControllerValue_get_value), -1);
  rb_define_method(SwigClassTexCoordModifierControllerValue.klass, "set_value", VALUEFUNC(_wrap_TexCoordModifierControllerValue_set_value), -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, "get_value", VALUEFUNC(_wrap_FloatGpuParameterControllerValue_get_value), -1);
  rb_define_method(SwigClassFloatGpuParameterControllerValue.klass, "set_value", VALUEFUNC(_wrap_FloatGpuParameterControllerValue_set_value), -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, "set_time", VALUEFUNC(_wrap_AnimationControllerFunction_set_time), -1);
  rb_define_method(SwigClassAnimationControllerFunction.klass, "set_sequence_time", VALUEFUNC(_wrap_AnimationControllerFunction_set_sequence_time), -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, "create_controller", VALUEFUNC(_wrap_ControllerManager_create_controller), -1);
  rb_define_method(SwigClassControllerManager.klass, "create_frame_time_passthrough_controller", VALUEFUNC(_wrap_ControllerManager_create_frame_time_passthrough_controller), -1);
  rb_define_method(SwigClassControllerManager.klass, "clear_controllers", VALUEFUNC(_wrap_ControllerManager_clear_controllers), -1);
  rb_define_method(SwigClassControllerManager.klass, "update_all_controllers", VALUEFUNC(_wrap_ControllerManager_update_all_controllers), -1);
  rb_define_method(SwigClassControllerManager.klass, "get_frame_time_source", VALUEFUNC(_wrap_ControllerManager_get_frame_time_source), -1);
  rb_define_method(SwigClassControllerManager.klass, "get_passthrough_controller_function", VALUEFUNC(_wrap_ControllerManager_get_passthrough_controller_function), -1);
  rb_define_method(SwigClassControllerManager.klass, "create_texture_animator", VALUEFUNC(_wrap_ControllerManager_create_texture_animator), -1);
  rb_define_method(SwigClassControllerManager.klass, "create_texture_uvscroller", VALUEFUNC(_wrap_ControllerManager_create_texture_uvscroller), -1);
  rb_define_method(SwigClassControllerManager.klass, "create_texture_uscroller", VALUEFUNC(_wrap_ControllerManager_create_texture_uscroller), -1);
  rb_define_method(SwigClassControllerManager.klass, "create_texture_vscroller", VALUEFUNC(_wrap_ControllerManager_create_texture_vscroller), -1);
  rb_define_method(SwigClassControllerManager.klass, "create_texture_rotater", VALUEFUNC(_wrap_ControllerManager_create_texture_rotater), -1);
  rb_define_method(SwigClassControllerManager.klass, "create_texture_wave_transformer", VALUEFUNC(_wrap_ControllerManager_create_texture_wave_transformer), -1);
  rb_define_method(SwigClassControllerManager.klass, "create_gpu_program_timer_param", VALUEFUNC(_wrap_ControllerManager_create_gpu_program_timer_param), -1);
  rb_define_method(SwigClassControllerManager.klass, "destroy_controller", VALUEFUNC(_wrap_ControllerManager_destroy_controller), -1);
  rb_define_method(SwigClassControllerManager.klass, "get_time_factor", VALUEFUNC(_wrap_ControllerManager_get_time_factor), -1);
  rb_define_method(SwigClassControllerManager.klass, "set_time_factor", VALUEFUNC(_wrap_ControllerManager_set_time_factor), -1);
  rb_define_method(SwigClassControllerManager.klass, "get_frame_delay", VALUEFUNC(_wrap_ControllerManager_get_frame_delay), -1);
  rb_define_method(SwigClassControllerManager.klass, "set_frame_delay", VALUEFUNC(_wrap_ControllerManager_set_frame_delay), -1);
  rb_define_method(SwigClassControllerManager.klass, "get_elapsed_time", VALUEFUNC(_wrap_ControllerManager_get_elapsed_time), -1);
  rb_define_method(SwigClassControllerManager.klass, "set_elapsed_time", VALUEFUNC(_wrap_ControllerManager_set_elapsed_time), -1);
  rb_define_singleton_method(SwigClassControllerManager.klass, "get_singleton", VALUEFUNC(_wrap_ControllerManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassControllerManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_ControllerManager_get_singleton_ptr), -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, "insert_vertex", VALUEFUNC(_wrap_Polygon_insert_vertex), -1);
  rb_define_method(SwigClassPolygon.klass, "get_vertex", VALUEFUNC(_wrap_Polygon_get_vertex), -1);
  rb_define_method(SwigClassPolygon.klass, "set_vertex", VALUEFUNC(_wrap_Polygon_set_vertex), -1);
  rb_define_method(SwigClassPolygon.klass, "remove_duplicates", VALUEFUNC(_wrap_Polygon_remove_duplicates), -1);
  rb_define_method(SwigClassPolygon.klass, "get_vertex_count", VALUEFUNC(_wrap_Polygon_get_vertex_count), -1);
  rb_define_method(SwigClassPolygon.klass, "get_normal", VALUEFUNC(_wrap_Polygon_get_normal), -1);
  rb_define_method(SwigClassPolygon.klass, "delete_vertex", VALUEFUNC(_wrap_Polygon_delete_vertex), -1);
  rb_define_method(SwigClassPolygon.klass, "is_point_inside", VALUEFUNC(_wrap_Polygon_is_point_inside), -1);
  rb_define_method(SwigClassPolygon.klass, "store_edges", VALUEFUNC(_wrap_Polygon_store_edges), -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, "get_polygon_count", VALUEFUNC(_wrap_ConvexBody_get_polygon_count), -1);
  rb_define_method(SwigClassConvexBody.klass, "get_vertex_count", VALUEFUNC(_wrap_ConvexBody_get_vertex_count), -1);
  rb_define_method(SwigClassConvexBody.klass, "get_polygon", VALUEFUNC(_wrap_ConvexBody_get_polygon), -1);
  rb_define_method(SwigClassConvexBody.klass, "get_vertex", VALUEFUNC(_wrap_ConvexBody_get_vertex), -1);
  rb_define_method(SwigClassConvexBody.klass, "get_normal", VALUEFUNC(_wrap_ConvexBody_get_normal), -1);
  rb_define_method(SwigClassConvexBody.klass, "get_aabb", VALUEFUNC(_wrap_ConvexBody_get_aabb), -1);
  rb_define_method(SwigClassConvexBody.klass, "has_closed_hull", VALUEFUNC(_wrap_ConvexBody_has_closed_hull), -1);
  rb_define_method(SwigClassConvexBody.klass, "merge_polygons", VALUEFUNC(_wrap_ConvexBody_merge_polygons), -1);
  rb_define_method(SwigClassConvexBody.klass, "==", VALUEFUNC(_wrap_ConvexBody___eq__), -1);
  rb_define_method(SwigClassConvexBody.klass, "log_info", VALUEFUNC(_wrap_ConvexBody_log_info), -1);
  rb_define_singleton_method(SwigClassConvexBody.klass, "_initialise_pool", VALUEFUNC(_wrap_ConvexBody__initialise_pool), -1);
  rb_define_singleton_method(SwigClassConvexBody.klass, "_destroy_pool", VALUEFUNC(_wrap_ConvexBody__destroy_pool), -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, "create_operation", VALUEFUNC(_wrap_CustomCompositionPass_create_operation), -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, "get_data_type", VALUEFUNC(_wrap_ImageCodec_get_data_type), -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, "code_to_file", VALUEFUNC(_wrap_DDSCodec_code_to_file), -1);
  rb_define_method(SwigClassDDSCodec.klass, "decode", VALUEFUNC(_wrap_DDSCodec_decode), -1);
  rb_define_method(SwigClassDDSCodec.klass, "magic_number_to_file_ext", VALUEFUNC(_wrap_DDSCodec_magic_number_to_file_ext), -1);
  rb_define_method(SwigClassDDSCodec.klass, "get_type", VALUEFUNC(_wrap_DDSCodec_get_type), -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, "get_vertex_declaration", VALUEFUNC(_wrap_RenderToVertexBuffer_get_vertex_declaration), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "get_max_vertex_count", VALUEFUNC(_wrap_RenderToVertexBuffer_get_max_vertex_count), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "set_max_vertex_count", VALUEFUNC(_wrap_RenderToVertexBuffer_set_max_vertex_count), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "get_operation_type", VALUEFUNC(_wrap_RenderToVertexBuffer_get_operation_type), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "set_operation_type", VALUEFUNC(_wrap_RenderToVertexBuffer_set_operation_type), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "set_resets_every_update", VALUEFUNC(_wrap_RenderToVertexBuffer_set_resets_every_update), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "get_resets_every_update", VALUEFUNC(_wrap_RenderToVertexBuffer_get_resets_every_update), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "get_render_operation", VALUEFUNC(_wrap_RenderToVertexBuffer_get_render_operation), -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, "set_source_renderable", VALUEFUNC(_wrap_RenderToVertexBuffer_set_source_renderable), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "get_source_renderable", VALUEFUNC(_wrap_RenderToVertexBuffer_get_source_renderable), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "get_render_to_buffer_material", VALUEFUNC(_wrap_RenderToVertexBuffer_get_render_to_buffer_material), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "set_render_to_buffer_material_name", VALUEFUNC(_wrap_RenderToVertexBuffer_set_render_to_buffer_material_name), -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, "license_expired", VALUEFUNC(_wrap_HardwareBufferLicensee_license_expired), -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, "extract_from", VALUEFUNC(_wrap_TempBlendedBufferInfo_extract_from), -1);
  rb_define_method(SwigClassTempBlendedBufferInfo.klass, "checkout_temp_copies", VALUEFUNC(_wrap_TempBlendedBufferInfo_checkout_temp_copies), -1);
  rb_define_method(SwigClassTempBlendedBufferInfo.klass, "bind_temp_copies", VALUEFUNC(_wrap_TempBlendedBufferInfo_bind_temp_copies), -1);
  rb_define_method(SwigClassTempBlendedBufferInfo.klass, "license_expired", VALUEFUNC(_wrap_TempBlendedBufferInfo_license_expired), -1);
  rb_define_method(SwigClassTempBlendedBufferInfo.klass, "buffers_checked_out", VALUEFUNC(_wrap_TempBlendedBufferInfo_buffers_checked_out), -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, "create_vertex_buffer", VALUEFUNC(_wrap_HardwareBufferManagerBase_create_vertex_buffer), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "create_index_buffer", VALUEFUNC(_wrap_HardwareBufferManagerBase_create_index_buffer), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "create_render_to_vertex_buffer", VALUEFUNC(_wrap_HardwareBufferManagerBase_create_render_to_vertex_buffer), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "create_vertex_declaration", VALUEFUNC(_wrap_HardwareBufferManagerBase_create_vertex_declaration), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "destroy_vertex_declaration", VALUEFUNC(_wrap_HardwareBufferManagerBase_destroy_vertex_declaration), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "create_vertex_buffer_binding", VALUEFUNC(_wrap_HardwareBufferManagerBase_create_vertex_buffer_binding), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "destroy_vertex_buffer_binding", VALUEFUNC(_wrap_HardwareBufferManagerBase_destroy_vertex_buffer_binding), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "register_vertex_buffer_source_and_copy", VALUEFUNC(_wrap_HardwareBufferManagerBase_register_vertex_buffer_source_and_copy), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "allocate_vertex_buffer_copy", VALUEFUNC(_wrap_HardwareBufferManagerBase_allocate_vertex_buffer_copy), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "release_vertex_buffer_copy", VALUEFUNC(_wrap_HardwareBufferManagerBase_release_vertex_buffer_copy), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "touch_vertex_buffer_copy", VALUEFUNC(_wrap_HardwareBufferManagerBase_touch_vertex_buffer_copy), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "_free_unused_buffer_copies", VALUEFUNC(_wrap_HardwareBufferManagerBase__free_unused_buffer_copies), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "_release_buffer_copies", VALUEFUNC(_wrap_HardwareBufferManagerBase__release_buffer_copies), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "_force_release_buffer_copies", VALUEFUNC(_wrap_HardwareBufferManagerBase__force_release_buffer_copies), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "_notify_vertex_buffer_destroyed", VALUEFUNC(_wrap_HardwareBufferManagerBase__notify_vertex_buffer_destroyed), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "_notify_index_buffer_destroyed", VALUEFUNC(_wrap_HardwareBufferManagerBase__notify_index_buffer_destroyed), -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, "create_vertex_buffer", VALUEFUNC(_wrap_HardwareBufferManager_create_vertex_buffer), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "create_index_buffer", VALUEFUNC(_wrap_HardwareBufferManager_create_index_buffer), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "create_render_to_vertex_buffer", VALUEFUNC(_wrap_HardwareBufferManager_create_render_to_vertex_buffer), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "create_vertex_declaration", VALUEFUNC(_wrap_HardwareBufferManager_create_vertex_declaration), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "destroy_vertex_declaration", VALUEFUNC(_wrap_HardwareBufferManager_destroy_vertex_declaration), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "create_vertex_buffer_binding", VALUEFUNC(_wrap_HardwareBufferManager_create_vertex_buffer_binding), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "destroy_vertex_buffer_binding", VALUEFUNC(_wrap_HardwareBufferManager_destroy_vertex_buffer_binding), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "register_vertex_buffer_source_and_copy", VALUEFUNC(_wrap_HardwareBufferManager_register_vertex_buffer_source_and_copy), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "allocate_vertex_buffer_copy", VALUEFUNC(_wrap_HardwareBufferManager_allocate_vertex_buffer_copy), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "release_vertex_buffer_copy", VALUEFUNC(_wrap_HardwareBufferManager_release_vertex_buffer_copy), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "touch_vertex_buffer_copy", VALUEFUNC(_wrap_HardwareBufferManager_touch_vertex_buffer_copy), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "_free_unused_buffer_copies", VALUEFUNC(_wrap_HardwareBufferManager__free_unused_buffer_copies), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "_release_buffer_copies", VALUEFUNC(_wrap_HardwareBufferManager__release_buffer_copies), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "_force_release_buffer_copies", VALUEFUNC(_wrap_HardwareBufferManager__force_release_buffer_copies), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "_notify_vertex_buffer_destroyed", VALUEFUNC(_wrap_HardwareBufferManager__notify_vertex_buffer_destroyed), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "_notify_index_buffer_destroyed", VALUEFUNC(_wrap_HardwareBufferManager__notify_index_buffer_destroyed), -1);
  rb_define_singleton_method(SwigClassHardwareBufferManager.klass, "get_singleton", VALUEFUNC(_wrap_HardwareBufferManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassHardwareBufferManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_HardwareBufferManager_get_singleton_ptr), -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, "read_data", VALUEFUNC(_wrap_DefaultHardwareVertexBuffer_read_data), -1);
  rb_define_method(SwigClassDefaultHardwareVertexBuffer.klass, "write_data", VALUEFUNC(_wrap_DefaultHardwareVertexBuffer_write_data), -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, "read_data", VALUEFUNC(_wrap_DefaultHardwareIndexBuffer_read_data), -1);
  rb_define_method(SwigClassDefaultHardwareIndexBuffer.klass, "write_data", VALUEFUNC(_wrap_DefaultHardwareIndexBuffer_write_data), -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, "create_vertex_buffer", VALUEFUNC(_wrap_DefaultHardwareBufferManagerBase_create_vertex_buffer), -1);
  rb_define_method(SwigClassDefaultHardwareBufferManagerBase.klass, "create_index_buffer", VALUEFUNC(_wrap_DefaultHardwareBufferManagerBase_create_index_buffer), -1);
  rb_define_method(SwigClassDefaultHardwareBufferManagerBase.klass, "create_render_to_vertex_buffer", VALUEFUNC(_wrap_DefaultHardwareBufferManagerBase_create_render_to_vertex_buffer), -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, "is_compressed_stream_valid", VALUEFUNC(_wrap_DeflateStream_is_compressed_stream_valid), -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, "_set_pool_id", VALUEFUNC(_wrap_DepthBuffer__set_pool_id), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "get_pool_id", VALUEFUNC(_wrap_DepthBuffer_get_pool_id), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "get_bit_depth", VALUEFUNC(_wrap_DepthBuffer_get_bit_depth), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "get_width", VALUEFUNC(_wrap_DepthBuffer_get_width), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "get_height", VALUEFUNC(_wrap_DepthBuffer_get_height), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "get_fsaa", VALUEFUNC(_wrap_DepthBuffer_get_fsaa), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "get_fsaa_hint", VALUEFUNC(_wrap_DepthBuffer_get_fsaa_hint), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "is_manual", VALUEFUNC(_wrap_DepthBuffer_is_manual), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "is_compatible", VALUEFUNC(_wrap_DepthBuffer_is_compatible), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "_notify_render_target_attached", VALUEFUNC(_wrap_DepthBuffer__notify_render_target_attached), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "_notify_render_target_detached", VALUEFUNC(_wrap_DepthBuffer__notify_render_target_detached), -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, "get_base_value", VALUEFUNC(_wrap_LodStrategy_get_base_value), -1);
  rb_define_method(SwigClassLodStrategy.klass, "transform_bias", VALUEFUNC(_wrap_LodStrategy_transform_bias), -1);
  rb_define_method(SwigClassLodStrategy.klass, "transform_user_value", VALUEFUNC(_wrap_LodStrategy_transform_user_value), -1);
  rb_define_method(SwigClassLodStrategy.klass, "get_value", VALUEFUNC(_wrap_LodStrategy_get_value), -1);
  rb_define_method(SwigClassLodStrategy.klass, "get_index", VALUEFUNC(_wrap_LodStrategy_get_index), -1);
  rb_define_method(SwigClassLodStrategy.klass, "sort", VALUEFUNC(_wrap_LodStrategy_sort), -1);
  rb_define_method(SwigClassLodStrategy.klass, "is_sorted", VALUEFUNC(_wrap_LodStrategy_is_sorted), -1);
  rb_define_method(SwigClassLodStrategy.klass, "assert_sorted", VALUEFUNC(_wrap_LodStrategy_assert_sorted), -1);
  rb_define_method(SwigClassLodStrategy.klass, "get_name", VALUEFUNC(_wrap_LodStrategy_get_name), -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, "get_base_value", VALUEFUNC(_wrap_DistanceLodStrategy_get_base_value), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "transform_bias", VALUEFUNC(_wrap_DistanceLodStrategy_transform_bias), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "transform_user_value", VALUEFUNC(_wrap_DistanceLodStrategy_transform_user_value), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "get_index", VALUEFUNC(_wrap_DistanceLodStrategy_get_index), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "sort", VALUEFUNC(_wrap_DistanceLodStrategy_sort), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "is_sorted", VALUEFUNC(_wrap_DistanceLodStrategy_is_sorted), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "set_reference_view", VALUEFUNC(_wrap_DistanceLodStrategy_set_reference_view), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "set_reference_view_enabled", VALUEFUNC(_wrap_DistanceLodStrategy_set_reference_view_enabled), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "get_reference_view_enabled", VALUEFUNC(_wrap_DistanceLodStrategy_get_reference_view_enabled), -1);
  rb_define_singleton_method(SwigClassDistanceLodStrategy.klass, "get_singleton", VALUEFUNC(_wrap_DistanceLodStrategy_get_singleton), -1);
  rb_define_singleton_method(SwigClassDistanceLodStrategy.klass, "get_singleton_ptr", VALUEFUNC(_wrap_DistanceLodStrategy_get_singleton_ptr), -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, "is_na_n", VALUEFUNC(_wrap_DualQuaternion_is_na_n), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "from_rotation_translation", VALUEFUNC(_wrap_DualQuaternion_from_rotation_translation), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "to_rotation_translation", VALUEFUNC(_wrap_DualQuaternion_to_rotation_translation), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "from_transformation_matrix", VALUEFUNC(_wrap_DualQuaternion_from_transformation_matrix), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "to_transformation_matrix", VALUEFUNC(_wrap_DualQuaternion_to_transformation_matrix), -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, "get_name", VALUEFUNC(_wrap_DynLib_get_name), -1);
  rb_define_method(SwigClassDynLib.klass, "get_symbol", VALUEFUNC(_wrap_DynLib_get_symbol), -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, "get_singleton", VALUEFUNC(_wrap_DynLibManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassDynLibManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_DynLibManager_get_singleton_ptr), -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, "update_triangle_light_facing", VALUEFUNC(_wrap_EdgeData_update_triangle_light_facing), -1);
  rb_define_method(SwigClassEdgeData.klass, "update_face_normals", VALUEFUNC(_wrap_EdgeData_update_face_normals), -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, "add_vertex_data", VALUEFUNC(_wrap_EdgeListBuilder_add_vertex_data), -1);
  rb_define_method(SwigClassEdgeListBuilder.klass, "add_index_data", VALUEFUNC(_wrap_EdgeListBuilder_add_index_data), -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, "get_mesh", VALUEFUNC(_wrap_Entity_get_mesh), -1);
  rb_define_method(SwigClassEntity.klass, "get_sub_entity", VALUEFUNC(_wrap_Entity_get_sub_entity), -1);
  rb_define_method(SwigClassEntity.klass, "get_num_sub_entities", VALUEFUNC(_wrap_Entity_get_num_sub_entities), -1);
  rb_define_method(SwigClassEntity.klass, "clone", VALUEFUNC(_wrap_Entity_clone), -1);
  rb_define_method(SwigClassEntity.klass, "set_material_name", VALUEFUNC(_wrap_Entity_set_material_name), -1);
  rb_define_method(SwigClassEntity.klass, "set_material", VALUEFUNC(_wrap_Entity_set_material), -1);
  rb_define_method(SwigClassEntity.klass, "_notify_current_camera", VALUEFUNC(_wrap_Entity__notify_current_camera), -1);
  rb_define_method(SwigClassEntity.klass, "set_render_queue_group", VALUEFUNC(_wrap_Entity_set_render_queue_group), -1);
  rb_define_method(SwigClassEntity.klass, "set_render_queue_group_and_priority", VALUEFUNC(_wrap_Entity_set_render_queue_group_and_priority), -1);
  rb_define_method(SwigClassEntity.klass, "get_bounding_box", VALUEFUNC(_wrap_Entity_get_bounding_box), -1);
  rb_define_method(SwigClassEntity.klass, "get_child_objects_bounding_box", VALUEFUNC(_wrap_Entity_get_child_objects_bounding_box), -1);
  rb_define_method(SwigClassEntity.klass, "_update_render_queue", VALUEFUNC(_wrap_Entity__update_render_queue), -1);
  rb_define_method(SwigClassEntity.klass, "get_movable_type", VALUEFUNC(_wrap_Entity_get_movable_type), -1);
  rb_define_method(SwigClassEntity.klass, "get_animation_state", VALUEFUNC(_wrap_Entity_get_animation_state), -1);
  rb_define_method(SwigClassEntity.klass, "has_animation_state", VALUEFUNC(_wrap_Entity_has_animation_state), -1);
  rb_define_method(SwigClassEntity.klass, "get_all_animation_states", VALUEFUNC(_wrap_Entity_get_all_animation_states), -1);
  rb_define_method(SwigClassEntity.klass, "set_display_skeleton", VALUEFUNC(_wrap_Entity_set_display_skeleton), -1);
  rb_define_method(SwigClassEntity.klass, "get_display_skeleton", VALUEFUNC(_wrap_Entity_get_display_skeleton), -1);
  rb_define_method(SwigClassEntity.klass, "get_manual_lod_level", VALUEFUNC(_wrap_Entity_get_manual_lod_level), -1);
  rb_define_method(SwigClassEntity.klass, "get_num_manual_lod_levels", VALUEFUNC(_wrap_Entity_get_num_manual_lod_levels), -1);
  rb_define_method(SwigClassEntity.klass, "get_current_lod_index", VALUEFUNC(_wrap_Entity_get_current_lod_index), -1);
  rb_define_method(SwigClassEntity.klass, "set_mesh_lod_bias", VALUEFUNC(_wrap_Entity_set_mesh_lod_bias), -1);
  rb_define_method(SwigClassEntity.klass, "set_material_lod_bias", VALUEFUNC(_wrap_Entity_set_material_lod_bias), -1);
  rb_define_method(SwigClassEntity.klass, "set_polygon_mode_overrideable", VALUEFUNC(_wrap_Entity_set_polygon_mode_overrideable), -1);
  rb_define_method(SwigClassEntity.klass, "attach_object_to_bone", VALUEFUNC(_wrap_Entity_attach_object_to_bone), -1);
  rb_define_method(SwigClassEntity.klass, "detach_object_from_bone", VALUEFUNC(_wrap_Entity_detach_object_from_bone), -1);
  rb_define_method(SwigClassEntity.klass, "detach_all_objects_from_bone", VALUEFUNC(_wrap_Entity_detach_all_objects_from_bone), -1);
  rb_define_method(SwigClassEntity.klass, "get_attached_object_iterator", VALUEFUNC(_wrap_Entity_get_attached_object_iterator), -1);
  rb_define_method(SwigClassEntity.klass, "get_bounding_radius", VALUEFUNC(_wrap_Entity_get_bounding_radius), -1);
  rb_define_method(SwigClassEntity.klass, "get_world_bounding_box", VALUEFUNC(_wrap_Entity_get_world_bounding_box), -1);
  rb_define_method(SwigClassEntity.klass, "get_world_bounding_sphere", VALUEFUNC(_wrap_Entity_get_world_bounding_sphere), -1);
  rb_define_method(SwigClassEntity.klass, "get_edge_list", VALUEFUNC(_wrap_Entity_get_edge_list), -1);
  rb_define_method(SwigClassEntity.klass, "has_edge_list", VALUEFUNC(_wrap_Entity_has_edge_list), -1);
  rb_define_method(SwigClassEntity.klass, "get_shadow_volume_renderable_iterator", VALUEFUNC(_wrap_Entity_get_shadow_volume_renderable_iterator), -1);
  rb_define_method(SwigClassEntity.klass, "_get_bone_matrices", VALUEFUNC(_wrap_Entity__get_bone_matrices), -1);
  rb_define_method(SwigClassEntity.klass, "_get_num_bone_matrices", VALUEFUNC(_wrap_Entity__get_num_bone_matrices), -1);
  rb_define_method(SwigClassEntity.klass, "has_skeleton", VALUEFUNC(_wrap_Entity_has_skeleton), -1);
  rb_define_method(SwigClassEntity.klass, "get_skeleton", VALUEFUNC(_wrap_Entity_get_skeleton), -1);
  rb_define_method(SwigClassEntity.klass, "is_hardware_animation_enabled", VALUEFUNC(_wrap_Entity_is_hardware_animation_enabled), -1);
  rb_define_method(SwigClassEntity.klass, "_notify_attached", VALUEFUNC(_wrap_Entity__notify_attached), -1);
  rb_define_method(SwigClassEntity.klass, "get_software_animation_requests", VALUEFUNC(_wrap_Entity_get_software_animation_requests), -1);
  rb_define_method(SwigClassEntity.klass, "get_software_animation_normals_requests", VALUEFUNC(_wrap_Entity_get_software_animation_normals_requests), -1);
  rb_define_method(SwigClassEntity.klass, "add_software_animation_request", VALUEFUNC(_wrap_Entity_add_software_animation_request), -1);
  rb_define_method(SwigClassEntity.klass, "remove_software_animation_request", VALUEFUNC(_wrap_Entity_remove_software_animation_request), -1);
  rb_define_method(SwigClassEntity.klass, "share_skeleton_instance_with", VALUEFUNC(_wrap_Entity_share_skeleton_instance_with), -1);
  rb_define_method(SwigClassEntity.klass, "has_vertex_animation", VALUEFUNC(_wrap_Entity_has_vertex_animation), -1);
  rb_define_method(SwigClassEntity.klass, "stop_sharing_skeleton_instance", VALUEFUNC(_wrap_Entity_stop_sharing_skeleton_instance), -1);
  rb_define_method(SwigClassEntity.klass, "shares_skeleton_instance", VALUEFUNC(_wrap_Entity_shares_skeleton_instance), -1);
  rb_define_method(SwigClassEntity.klass, "get_skeleton_instance_sharing_set", VALUEFUNC(_wrap_Entity_get_skeleton_instance_sharing_set), -1);
  rb_define_method(SwigClassEntity.klass, "refresh_available_animation_state", VALUEFUNC(_wrap_Entity_refresh_available_animation_state), -1);
  rb_define_method(SwigClassEntity.klass, "_update_animation", VALUEFUNC(_wrap_Entity__update_animation), -1);
  rb_define_method(SwigClassEntity.klass, "_is_animated", VALUEFUNC(_wrap_Entity__is_animated), -1);
  rb_define_method(SwigClassEntity.klass, "_is_skeleton_animated", VALUEFUNC(_wrap_Entity__is_skeleton_animated), -1);
  rb_define_method(SwigClassEntity.klass, "_get_skel_anim_vertex_data", VALUEFUNC(_wrap_Entity__get_skel_anim_vertex_data), -1);
  rb_define_method(SwigClassEntity.klass, "_get_software_vertex_anim_vertex_data", VALUEFUNC(_wrap_Entity__get_software_vertex_anim_vertex_data), -1);
  rb_define_method(SwigClassEntity.klass, "_get_hardware_vertex_anim_vertex_data", VALUEFUNC(_wrap_Entity__get_hardware_vertex_anim_vertex_data), -1);
  rb_define_method(SwigClassEntity.klass, "_get_skel_anim_temp_buffer_info", VALUEFUNC(_wrap_Entity__get_skel_anim_temp_buffer_info), -1);
  rb_define_method(SwigClassEntity.klass, "_get_vertex_anim_temp_buffer_info", VALUEFUNC(_wrap_Entity__get_vertex_anim_temp_buffer_info), -1);
  rb_define_method(SwigClassEntity.klass, "get_type_flags", VALUEFUNC(_wrap_Entity_get_type_flags), -1);
  rb_define_method(SwigClassEntity.klass, "get_vertex_data_for_binding", VALUEFUNC(_wrap_Entity_get_vertex_data_for_binding), -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, "choose_vertex_data_for_binding", VALUEFUNC(_wrap_Entity_choose_vertex_data_for_binding), -1);
  rb_define_method(SwigClassEntity.klass, "_get_buffers_marked_for_animation", VALUEFUNC(_wrap_Entity__get_buffers_marked_for_animation), -1);
  rb_define_method(SwigClassEntity.klass, "_mark_buffers_used_for_animation", VALUEFUNC(_wrap_Entity__mark_buffers_used_for_animation), -1);
  rb_define_method(SwigClassEntity.klass, "is_initialised", VALUEFUNC(_wrap_Entity_is_initialised), -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, "background_loading_complete", VALUEFUNC(_wrap_Entity_background_loading_complete), -1);
  rb_define_method(SwigClassEntity.klass, "visit_renderables", VALUEFUNC(_wrap_Entity_visit_renderables), -1);
  rb_define_method(SwigClassEntity.klass, "_get_mesh_lod_factor_transformed", VALUEFUNC(_wrap_Entity__get_mesh_lod_factor_transformed), -1);
  rb_define_method(SwigClassEntity.klass, "set_skip_animation_state_update", VALUEFUNC(_wrap_Entity_set_skip_animation_state_update), -1);
  rb_define_method(SwigClassEntity.klass, "get_skip_animation_state_update", VALUEFUNC(_wrap_Entity_get_skip_animation_state_update), -1);
  rb_define_method(SwigClassEntity.klass, "set_always_update_main_skeleton", VALUEFUNC(_wrap_Entity_set_always_update_main_skeleton), -1);
  rb_define_method(SwigClassEntity.klass, "get_always_update_main_skeleton", VALUEFUNC(_wrap_Entity_get_always_update_main_skeleton), -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, "get_type", VALUEFUNC(_wrap_EntityFactory_get_type), -1);
  rb_define_method(SwigClassEntityFactory.klass, "destroy_instance", VALUEFUNC(_wrap_EntityFactory_destroy_instance), -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, "set_input_name", VALUEFUNC(_wrap_ExternalTextureSource_set_input_name), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "get_input_name", VALUEFUNC(_wrap_ExternalTextureSource_get_input_name), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "set_fps", VALUEFUNC(_wrap_ExternalTextureSource_set_fps), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "get_fps", VALUEFUNC(_wrap_ExternalTextureSource_get_fps), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "set_play_mode", VALUEFUNC(_wrap_ExternalTextureSource_set_play_mode), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "get_play_mode", VALUEFUNC(_wrap_ExternalTextureSource_get_play_mode), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "set_texture_tec_pass_state_level", VALUEFUNC(_wrap_ExternalTextureSource_set_texture_tec_pass_state_level), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "get_texture_tec_pass_state_level", VALUEFUNC(_wrap_ExternalTextureSource_get_texture_tec_pass_state_level), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "add_base_params", VALUEFUNC(_wrap_ExternalTextureSource_add_base_params), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "get_plugin_string_name", VALUEFUNC(_wrap_ExternalTextureSource_get_plugin_string_name), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "get_dictionary_string_name", VALUEFUNC(_wrap_ExternalTextureSource_get_dictionary_string_name), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "initialise", VALUEFUNC(_wrap_ExternalTextureSource_initialise), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "shut_down", VALUEFUNC(_wrap_ExternalTextureSource_shut_down), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "create_defined_texture", VALUEFUNC(_wrap_ExternalTextureSource_create_defined_texture), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "destroy_advanced_texture", VALUEFUNC(_wrap_ExternalTextureSource_destroy_advanced_texture), -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, "set_current_plug_in", VALUEFUNC(_wrap_ExternalTextureSourceManager_set_current_plug_in), -1);
  rb_define_method(SwigClassExternalTextureSourceManager.klass, "get_current_plug_in", VALUEFUNC(_wrap_ExternalTextureSourceManager_get_current_plug_in), -1);
  rb_define_method(SwigClassExternalTextureSourceManager.klass, "destroy_advanced_texture", VALUEFUNC(_wrap_ExternalTextureSourceManager_destroy_advanced_texture), -1);
  rb_define_method(SwigClassExternalTextureSourceManager.klass, "get_external_texture_source", VALUEFUNC(_wrap_ExternalTextureSourceManager_get_external_texture_source), -1);
  rb_define_method(SwigClassExternalTextureSourceManager.klass, "set_external_texture_source", VALUEFUNC(_wrap_ExternalTextureSourceManager_set_external_texture_source), -1);
  rb_define_singleton_method(SwigClassExternalTextureSourceManager.klass, "get_singleton", VALUEFUNC(_wrap_ExternalTextureSourceManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassExternalTextureSourceManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_ExternalTextureSourceManager_get_singleton_ptr), -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, "is_case_sensitive", VALUEFUNC(_wrap_FileSystemArchive_is_case_sensitive), -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, "list_file_info", VALUEFUNC(_wrap_FileSystemArchive_list_file_info), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "find", VALUEFUNC(_wrap_FileSystemArchive_find), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "find_file_info", VALUEFUNC(_wrap_FileSystemArchive_find_file_info), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "exists", VALUEFUNC(_wrap_FileSystemArchive_exists), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "get_modified_time", VALUEFUNC(_wrap_FileSystemArchive_get_modified_time), -1);
  rb_define_singleton_method(SwigClassFileSystemArchive.klass, "set_ignore_hidden", VALUEFUNC(_wrap_FileSystemArchive_set_ignore_hidden), -1);
  rb_define_singleton_method(SwigClassFileSystemArchive.klass, "get_ignore_hidden", VALUEFUNC(_wrap_FileSystemArchive_get_ignore_hidden), -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, "get_type", VALUEFUNC(_wrap_FileSystemArchiveFactory_get_type), -1);
  rb_define_method(SwigClassFileSystemArchiveFactory.klass, "create_instance", VALUEFUNC(_wrap_FileSystemArchiveFactory_create_instance), -1);
  rb_define_method(SwigClassFileSystemArchiveFactory.klass, "destroy_instance", VALUEFUNC(_wrap_FileSystemArchiveFactory_destroy_instance), -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, "set_type", VALUEFUNC(_wrap_Font_set_type), -1);
  rb_define_method(SwigClassFont.klass, "get_type", VALUEFUNC(_wrap_Font_get_type), -1);
  rb_define_method(SwigClassFont.klass, "set_source", VALUEFUNC(_wrap_Font_set_source), -1);
  rb_define_method(SwigClassFont.klass, "get_source", VALUEFUNC(_wrap_Font_get_source), -1);
  rb_define_method(SwigClassFont.klass, "set_character_spacer", VALUEFUNC(_wrap_Font_set_character_spacer), -1);
  rb_define_method(SwigClassFont.klass, "get_character_spacer", VALUEFUNC(_wrap_Font_get_character_spacer), -1);
  rb_define_method(SwigClassFont.klass, "set_true_type_size", VALUEFUNC(_wrap_Font_set_true_type_size), -1);
  rb_define_method(SwigClassFont.klass, "set_true_type_resolution", VALUEFUNC(_wrap_Font_set_true_type_resolution), -1);
  rb_define_method(SwigClassFont.klass, "get_true_type_size", VALUEFUNC(_wrap_Font_get_true_type_size), -1);
  rb_define_method(SwigClassFont.klass, "get_true_type_resolution", VALUEFUNC(_wrap_Font_get_true_type_resolution), -1);
  rb_define_method(SwigClassFont.klass, "get_true_type_max_bearing_y", VALUEFUNC(_wrap_Font_get_true_type_max_bearing_y), -1);
  rb_define_method(SwigClassFont.klass, "get_glyph_tex_coords", VALUEFUNC(_wrap_Font_get_glyph_tex_coords), -1);
  rb_define_method(SwigClassFont.klass, "set_glyph_tex_coords", VALUEFUNC(_wrap_Font_set_glyph_tex_coords), -1);
  rb_define_method(SwigClassFont.klass, "get_glyph_aspect_ratio", VALUEFUNC(_wrap_Font_get_glyph_aspect_ratio), -1);
  rb_define_method(SwigClassFont.klass, "set_glyph_aspect_ratio", VALUEFUNC(_wrap_Font_set_glyph_aspect_ratio), -1);
  rb_define_method(SwigClassFont.klass, "get_glyph_info", VALUEFUNC(_wrap_Font_get_glyph_info), -1);
  rb_define_method(SwigClassFont.klass, "add_code_point_range", VALUEFUNC(_wrap_Font_add_code_point_range), -1);
  rb_define_method(SwigClassFont.klass, "clear_code_point_ranges", VALUEFUNC(_wrap_Font_clear_code_point_ranges), -1);
  rb_define_method(SwigClassFont.klass, "get_code_point_range_list", VALUEFUNC(_wrap_Font_get_code_point_range_list), -1);
  rb_define_method(SwigClassFont.klass, "get_material", VALUEFUNC(_wrap_Font_get_material), -1);
  rb_define_method(SwigClassFont.klass, "set_antialias_colour", VALUEFUNC(_wrap_Font_set_antialias_colour), -1);
  rb_define_method(SwigClassFont.klass, "get_antialias_colour", VALUEFUNC(_wrap_Font_get_antialias_colour), -1);
  rb_define_method(SwigClassFont.klass, "load_resource", VALUEFUNC(_wrap_Font_load_resource), -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, "parse_script", VALUEFUNC(_wrap_FontManager_parse_script), -1);
  rb_define_singleton_method(SwigClassFontManager.klass, "get_singleton", VALUEFUNC(_wrap_FontManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassFontManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_FontManager_get_singleton_ptr), -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, "code_to_file", VALUEFUNC(_wrap_FreeImageCodec_code_to_file), -1);
  rb_define_method(SwigClassFreeImageCodec.klass, "decode", VALUEFUNC(_wrap_FreeImageCodec_decode), -1);
  rb_define_method(SwigClassFreeImageCodec.klass, "get_type", VALUEFUNC(_wrap_FreeImageCodec_get_type), -1);
  rb_define_method(SwigClassFreeImageCodec.klass, "magic_number_to_file_ext", VALUEFUNC(_wrap_FreeImageCodec_magic_number_to_file_ext), -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, "load_from_string", VALUEFUNC(_wrap_GpuProgramManager_load_from_string), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "get_supported_syntax", VALUEFUNC(_wrap_GpuProgramManager_get_supported_syntax), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "is_syntax_supported", VALUEFUNC(_wrap_GpuProgramManager_is_syntax_supported), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "create_parameters", VALUEFUNC(_wrap_GpuProgramManager_create_parameters), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "create_program", VALUEFUNC(_wrap_GpuProgramManager_create_program), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "create_program_from_string", VALUEFUNC(_wrap_GpuProgramManager_create_program_from_string), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "create", VALUEFUNC(_wrap_GpuProgramManager_create), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "get_by_name", VALUEFUNC(_wrap_GpuProgramManager_get_by_name), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "create_shared_parameters", VALUEFUNC(_wrap_GpuProgramManager_create_shared_parameters), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "get_shared_parameters", VALUEFUNC(_wrap_GpuProgramManager_get_shared_parameters), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "get_available_shared_parameters", VALUEFUNC(_wrap_GpuProgramManager_get_available_shared_parameters), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "get_save_microcodes_to_cache", VALUEFUNC(_wrap_GpuProgramManager_get_save_microcodes_to_cache), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "set_save_microcodes_to_cache", VALUEFUNC(_wrap_GpuProgramManager_set_save_microcodes_to_cache), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "can_get_compiled_shader_buffer", VALUEFUNC(_wrap_GpuProgramManager_can_get_compiled_shader_buffer), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "is_microcode_available_in_cache", VALUEFUNC(_wrap_GpuProgramManager_is_microcode_available_in_cache), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "get_microcode_from_cache", VALUEFUNC(_wrap_GpuProgramManager_get_microcode_from_cache), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "create_microcode", VALUEFUNC(_wrap_GpuProgramManager_create_microcode), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "add_microcode_to_cache", VALUEFUNC(_wrap_GpuProgramManager_add_microcode_to_cache), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "save_microcode_cache", VALUEFUNC(_wrap_GpuProgramManager_save_microcode_cache), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "load_microcode_cache", VALUEFUNC(_wrap_GpuProgramManager_load_microcode_cache), -1);
  rb_define_singleton_method(SwigClassGpuProgramManager.klass, "get_singleton", VALUEFUNC(_wrap_GpuProgramManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassGpuProgramManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_GpuProgramManager_get_singleton_ptr), -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, "get_type", VALUEFUNC(_wrap_GpuProgramUsage_get_type), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "set_program_name", VALUEFUNC(_wrap_GpuProgramUsage_set_program_name), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "set_program", VALUEFUNC(_wrap_GpuProgramUsage_set_program), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "get_program", VALUEFUNC(_wrap_GpuProgramUsage_get_program), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "get_program_name", VALUEFUNC(_wrap_GpuProgramUsage_get_program_name), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "set_parameters", VALUEFUNC(_wrap_GpuProgramUsage_set_parameters), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "get_parameters", VALUEFUNC(_wrap_GpuProgramUsage_get_parameters), -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, "unloading_complete", VALUEFUNC(_wrap_GpuProgramUsage_unloading_complete), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "loading_complete", VALUEFUNC(_wrap_GpuProgramUsage_loading_complete), -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, "begin_occlusion_query", VALUEFUNC(_wrap_HardwareOcclusionQuery_begin_occlusion_query), -1);
  rb_define_method(SwigClassHardwareOcclusionQuery.klass, "end_occlusion_query", VALUEFUNC(_wrap_HardwareOcclusionQuery_end_occlusion_query), -1);
  rb_define_method(SwigClassHardwareOcclusionQuery.klass, "pull_occlusion_query", VALUEFUNC(_wrap_HardwareOcclusionQuery_pull_occlusion_query), -1);
  rb_define_method(SwigClassHardwareOcclusionQuery.klass, "get_last_querys_pixelcount", VALUEFUNC(_wrap_HardwareOcclusionQuery_get_last_querys_pixelcount), -1);
  rb_define_method(SwigClassHardwareOcclusionQuery.klass, "is_still_outstanding", VALUEFUNC(_wrap_HardwareOcclusionQuery_is_still_outstanding), -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, "get_current_lock", VALUEFUNC(_wrap_HardwarePixelBuffer_get_current_lock), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "read_data", VALUEFUNC(_wrap_HardwarePixelBuffer_read_data), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "write_data", VALUEFUNC(_wrap_HardwarePixelBuffer_write_data), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "blit", VALUEFUNC(_wrap_HardwarePixelBuffer_blit), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "blit_from_memory", VALUEFUNC(_wrap_HardwarePixelBuffer_blit_from_memory), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "blit_to_memory", VALUEFUNC(_wrap_HardwarePixelBuffer_blit_to_memory), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "get_render_target", VALUEFUNC(_wrap_HardwarePixelBuffer_get_render_target), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "get_width", VALUEFUNC(_wrap_HardwarePixelBuffer_get_width), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "get_height", VALUEFUNC(_wrap_HardwarePixelBuffer_get_height), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "get_depth", VALUEFUNC(_wrap_HardwarePixelBuffer_get_depth), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "get_format", VALUEFUNC(_wrap_HardwarePixelBuffer_get_format), -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, "create_parameters", VALUEFUNC(_wrap_HighLevelGpuProgram_create_parameters), -1);
  rb_define_method(SwigClassHighLevelGpuProgram.klass, "_get_binding_delegate", VALUEFUNC(_wrap_HighLevelGpuProgram__get_binding_delegate), -1);
  rb_define_method(SwigClassHighLevelGpuProgram.klass, "get_constant_definitions", VALUEFUNC(_wrap_HighLevelGpuProgram_get_constant_definitions), -1);
  rb_define_method(SwigClassHighLevelGpuProgram.klass, "get_named_constants", VALUEFUNC(_wrap_HighLevelGpuProgram_get_named_constants), -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, "get_language", VALUEFUNC(_wrap_HighLevelGpuProgramFactory_get_language), -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, "add_factory", VALUEFUNC(_wrap_HighLevelGpuProgramManager_add_factory), -1);
  rb_define_method(SwigClassHighLevelGpuProgramManager.klass, "remove_factory", VALUEFUNC(_wrap_HighLevelGpuProgramManager_remove_factory), -1);
  rb_define_method(SwigClassHighLevelGpuProgramManager.klass, "is_language_supported", VALUEFUNC(_wrap_HighLevelGpuProgramManager_is_language_supported), -1);
  rb_define_method(SwigClassHighLevelGpuProgramManager.klass, "create_program", VALUEFUNC(_wrap_HighLevelGpuProgramManager_create_program), -1);
  rb_define_singleton_method(SwigClassHighLevelGpuProgramManager.klass, "get_singleton", VALUEFUNC(_wrap_HighLevelGpuProgramManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassHighLevelGpuProgramManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_HighLevelGpuProgramManager_get_singleton_ptr), -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, "_get_mesh_ref", VALUEFUNC(_wrap_InstanceBatch__get_mesh_ref), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_set_instances_per_batch", VALUEFUNC(_wrap_InstanceBatch__set_instances_per_batch), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_get_index_to_bone_map", VALUEFUNC(_wrap_InstanceBatch__get_index_to_bone_map), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_supports_skeletal_animation", VALUEFUNC(_wrap_InstanceBatch__supports_skeletal_animation), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_update_bounds", VALUEFUNC(_wrap_InstanceBatch__update_bounds), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "calculate_max_num_instances", VALUEFUNC(_wrap_InstanceBatch_calculate_max_num_instances), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "build", VALUEFUNC(_wrap_InstanceBatch_build), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "build_from", VALUEFUNC(_wrap_InstanceBatch_build_from), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_get_mesh_reference", VALUEFUNC(_wrap_InstanceBatch__get_mesh_reference), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "is_batch_full", VALUEFUNC(_wrap_InstanceBatch_is_batch_full), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "is_batch_unused", VALUEFUNC(_wrap_InstanceBatch_is_batch_unused), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "get_instanced_entities_in_use", VALUEFUNC(_wrap_InstanceBatch_get_instanced_entities_in_use), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_defragment_batch", VALUEFUNC(_wrap_InstanceBatch__defragment_batch), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_defragment_batch_discard", VALUEFUNC(_wrap_InstanceBatch__defragment_batch_discard), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_bounds_dirty", VALUEFUNC(_wrap_InstanceBatch__bounds_dirty), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "set_static_and_update", VALUEFUNC(_wrap_InstanceBatch_set_static_and_update), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "is_static", VALUEFUNC(_wrap_InstanceBatch_is_static), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "create_instanced_entity", VALUEFUNC(_wrap_InstanceBatch_create_instanced_entity), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "remove_instanced_entity", VALUEFUNC(_wrap_InstanceBatch_remove_instanced_entity), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "use_bone_world_matrices", VALUEFUNC(_wrap_InstanceBatch_use_bone_world_matrices), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_mark_transform_sharing_dirty", VALUEFUNC(_wrap_InstanceBatch__mark_transform_sharing_dirty), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "get_material", VALUEFUNC(_wrap_InstanceBatch_get_material), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "get_render_operation", VALUEFUNC(_wrap_InstanceBatch_get_render_operation), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "get_squared_view_depth", VALUEFUNC(_wrap_InstanceBatch_get_squared_view_depth), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "get_lights", VALUEFUNC(_wrap_InstanceBatch_get_lights), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "get_technique", VALUEFUNC(_wrap_InstanceBatch_get_technique), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "get_movable_type", VALUEFUNC(_wrap_InstanceBatch_get_movable_type), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_notify_current_camera", VALUEFUNC(_wrap_InstanceBatch__notify_current_camera), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "get_bounding_box", VALUEFUNC(_wrap_InstanceBatch_get_bounding_box), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "get_bounding_radius", VALUEFUNC(_wrap_InstanceBatch_get_bounding_radius), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_update_render_queue", VALUEFUNC(_wrap_InstanceBatch__update_render_queue), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "visit_renderables", VALUEFUNC(_wrap_InstanceBatch_visit_renderables), -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, "calculate_max_num_instances", VALUEFUNC(_wrap_InstanceBatchHW_calculate_max_num_instances), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "build_from", VALUEFUNC(_wrap_InstanceBatchHW_build_from), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "_bounds_dirty", VALUEFUNC(_wrap_InstanceBatchHW__bounds_dirty), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "set_static_and_update", VALUEFUNC(_wrap_InstanceBatchHW_set_static_and_update), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "is_static", VALUEFUNC(_wrap_InstanceBatchHW_is_static), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "get_world_transforms", VALUEFUNC(_wrap_InstanceBatchHW_get_world_transforms), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "get_num_world_transforms", VALUEFUNC(_wrap_InstanceBatchHW_get_num_world_transforms), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "_update_render_queue", VALUEFUNC(_wrap_InstanceBatchHW__update_render_queue), -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, "build_from", VALUEFUNC(_wrap_BaseInstanceBatchVTF_build_from), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "get_world_transforms", VALUEFUNC(_wrap_BaseInstanceBatchVTF_get_world_transforms), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "get_num_world_transforms", VALUEFUNC(_wrap_BaseInstanceBatchVTF_get_num_world_transforms), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "_update_render_queue", VALUEFUNC(_wrap_BaseInstanceBatchVTF__update_render_queue), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "set_bone_matrix_lookup", VALUEFUNC(_wrap_BaseInstanceBatchVTF_set_bone_matrix_lookup), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "use_bone_matrix_lookup", VALUEFUNC(_wrap_BaseInstanceBatchVTF_use_bone_matrix_lookup), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "set_bone_dual_quaternions", VALUEFUNC(_wrap_BaseInstanceBatchVTF_set_bone_dual_quaternions), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "use_bone_dual_quaternions", VALUEFUNC(_wrap_BaseInstanceBatchVTF_use_bone_dual_quaternions), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "set_force_one_weight", VALUEFUNC(_wrap_BaseInstanceBatchVTF_set_force_one_weight), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "force_one_weight", VALUEFUNC(_wrap_BaseInstanceBatchVTF_force_one_weight), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "set_use_one_weight", VALUEFUNC(_wrap_BaseInstanceBatchVTF_set_use_one_weight), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "use_one_weight", VALUEFUNC(_wrap_BaseInstanceBatchVTF_use_one_weight), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "use_bone_world_matrices", VALUEFUNC(_wrap_BaseInstanceBatchVTF_use_bone_world_matrices), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "get_max_lookup_table_instances", VALUEFUNC(_wrap_BaseInstanceBatchVTF_get_max_lookup_table_instances), -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, "calculate_max_num_instances", VALUEFUNC(_wrap_InstanceBatchVTF_calculate_max_num_instances), -1);
  SwigClassInstanceBatchVTF.mark = 0;
  SwigClassInstanceBatchVTF.destroy = (void (*)(void *)) free_Ogre_InstanceBatchVTF;
  SwigClassInstanceBatchVTF.trackObjects = 0;
  
  SwigClassInstanceBatchHWVTF.klass = rb_define_class_under(mOgre, "InstanceBatchHWVTF", ((swig_class *) SWIGTYPE_p_Ogre__BaseInstanceBatchVTF->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__InstanceBatchHW_VTF, (void *) &SwigClassInstanceBatchHWVTF);
  rb_define_alloc_func(SwigClassInstanceBatchHWVTF.klass, _wrap_InstanceBatchHWVTF_allocate);
  rb_define_method(SwigClassInstanceBatchHWVTF.klass, "initialize", VALUEFUNC(_wrap_new_InstanceBatchHWVTF), -1);
  rb_define_method(SwigClassInstanceBatchHWVTF.klass, "calculate_max_num_instances", VALUEFUNC(_wrap_InstanceBatchHWVTF_calculate_max_num_instances), -1);
  rb_define_method(SwigClassInstanceBatchHWVTF.klass, "_bounds_dirty", VALUEFUNC(_wrap_InstanceBatchHWVTF__bounds_dirty), -1);
  rb_define_method(SwigClassInstanceBatchHWVTF.klass, "set_static_and_update", VALUEFUNC(_wrap_InstanceBatchHWVTF_set_static_and_update), -1);
  rb_define_method(SwigClassInstanceBatchHWVTF.klass, "is_static", VALUEFUNC(_wrap_InstanceBatchHWVTF_is_static), -1);
  rb_define_method(SwigClassInstanceBatchHWVTF.klass, "_update_render_queue", VALUEFUNC(_wrap_InstanceBatchHWVTF__update_render_queue), -1);
  SwigClassInstanceBatchHWVTF.mark = 0;
  SwigClassInstanceBatchHWVTF.destroy = (void (*)(void *)) free_Ogre_InstanceBatchHW_VTF;
  SwigClassInstanceBatchHWVTF.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, "calculate_max_num_instances", VALUEFUNC(_wrap_InstanceBatchShader_calculate_max_num_instances), -1);
  rb_define_method(SwigClassInstanceBatchShader.klass, "build_from", VALUEFUNC(_wrap_InstanceBatchShader_build_from), -1);
  rb_define_method(SwigClassInstanceBatchShader.klass, "get_world_transforms", VALUEFUNC(_wrap_InstanceBatchShader_get_world_transforms), -1);
  rb_define_method(SwigClassInstanceBatchShader.klass, "get_num_world_transforms", VALUEFUNC(_wrap_InstanceBatchShader_get_num_world_transforms), -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, "get_name", VALUEFUNC(_wrap_InstanceManager_get_name), -1);
  rb_define_method(SwigClassInstanceManager.klass, "set_instances_per_batch", VALUEFUNC(_wrap_InstanceManager_set_instances_per_batch), -1);
  rb_define_method(SwigClassInstanceManager.klass, "set_max_lookup_table_instances", VALUEFUNC(_wrap_InstanceManager_set_max_lookup_table_instances), -1);
  rb_define_method(SwigClassInstanceManager.klass, "get_max_or_best_num_instances_per_batch", VALUEFUNC(_wrap_InstanceManager_get_max_or_best_num_instances_per_batch), -1);
  rb_define_method(SwigClassInstanceManager.klass, "create_instanced_entity", VALUEFUNC(_wrap_InstanceManager_create_instanced_entity), -1);
  rb_define_method(SwigClassInstanceManager.klass, "cleanup_empty_batches", VALUEFUNC(_wrap_InstanceManager_cleanup_empty_batches), -1);
  rb_define_method(SwigClassInstanceManager.klass, "defragment_batches", VALUEFUNC(_wrap_InstanceManager_defragment_batches), -1);
  rb_define_method(SwigClassInstanceManager.klass, "set_setting", VALUEFUNC(_wrap_InstanceManager_set_setting), -1);
  rb_define_method(SwigClassInstanceManager.klass, "get_setting", VALUEFUNC(_wrap_InstanceManager_get_setting), -1);
  rb_define_method(SwigClassInstanceManager.klass, "has_settings", VALUEFUNC(_wrap_InstanceManager_has_settings), -1);
  rb_define_method(SwigClassInstanceManager.klass, "set_batches_as_static_and_update", VALUEFUNC(_wrap_InstanceManager_set_batches_as_static_and_update), -1);
  rb_define_method(SwigClassInstanceManager.klass, "_add_dirty_batch", VALUEFUNC(_wrap_InstanceManager__add_dirty_batch), -1);
  rb_define_method(SwigClassInstanceManager.klass, "_update_dirty_batches", VALUEFUNC(_wrap_InstanceManager__update_dirty_batches), -1);
  rb_define_method(SwigClassInstanceManager.klass, "get_instance_batch_map_iterator", VALUEFUNC(_wrap_InstanceManager_get_instance_batch_map_iterator), -1);
  rb_define_method(SwigClassInstanceManager.klass, "get_instance_batch_iterator", VALUEFUNC(_wrap_InstanceManager_get_instance_batch_iterator), -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, "share_transform_with", VALUEFUNC(_wrap_InstancedEntity_share_transform_with), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "stop_sharing_transform", VALUEFUNC(_wrap_InstancedEntity_stop_sharing_transform), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_get_owner", VALUEFUNC(_wrap_InstancedEntity__get_owner), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "get_movable_type", VALUEFUNC(_wrap_InstancedEntity_get_movable_type), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "get_bounding_box", VALUEFUNC(_wrap_InstancedEntity_get_bounding_box), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "get_bounding_radius", VALUEFUNC(_wrap_InstancedEntity_get_bounding_radius), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "get_squared_view_depth", VALUEFUNC(_wrap_InstancedEntity_get_squared_view_depth), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_notify_moved", VALUEFUNC(_wrap_InstancedEntity__notify_moved), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_notify_attached", VALUEFUNC(_wrap_InstancedEntity__notify_attached), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_update_render_queue", VALUEFUNC(_wrap_InstancedEntity__update_render_queue), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "visit_renderables", VALUEFUNC(_wrap_InstancedEntity_visit_renderables), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "has_skeleton", VALUEFUNC(_wrap_InstancedEntity_has_skeleton), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "get_skeleton", VALUEFUNC(_wrap_InstancedEntity_get_skeleton), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "get_animation_state", VALUEFUNC(_wrap_InstancedEntity_get_animation_state), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "get_all_animation_states", VALUEFUNC(_wrap_InstancedEntity_get_all_animation_states), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_update_animation", VALUEFUNC(_wrap_InstancedEntity__update_animation), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "set_transform_lookup_number", VALUEFUNC(_wrap_InstancedEntity_set_transform_lookup_number), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "get_position", VALUEFUNC(_wrap_InstancedEntity_get_position), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "set_position", VALUEFUNC(_wrap_InstancedEntity_set_position), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "get_orientation", VALUEFUNC(_wrap_InstancedEntity_get_orientation), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "set_orientation", VALUEFUNC(_wrap_InstancedEntity_set_orientation), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "get_scale", VALUEFUNC(_wrap_InstancedEntity_get_scale), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "set_scale", VALUEFUNC(_wrap_InstancedEntity_set_scale), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "get_max_scale_coef", VALUEFUNC(_wrap_InstancedEntity_get_max_scale_coef), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "update_transforms", VALUEFUNC(_wrap_InstancedEntity_update_transforms), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "is_in_use", VALUEFUNC(_wrap_InstancedEntity_is_in_use), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "set_in_use", VALUEFUNC(_wrap_InstancedEntity_set_in_use), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_get_parent_node_full_transform", VALUEFUNC(_wrap_InstancedEntity__get_parent_node_full_transform), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_get_derived_position", VALUEFUNC(_wrap_InstancedEntity__get_derived_position), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "is_in_scene", VALUEFUNC(_wrap_InstancedEntity_is_in_scene), -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, "set_material", VALUEFUNC(_wrap_SimpleRenderable_set_material), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "get_material", VALUEFUNC(_wrap_SimpleRenderable_get_material), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "set_render_operation", VALUEFUNC(_wrap_SimpleRenderable_set_render_operation), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "get_render_operation", VALUEFUNC(_wrap_SimpleRenderable_get_render_operation), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "set_world_transform", VALUEFUNC(_wrap_SimpleRenderable_set_world_transform), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "get_world_transforms", VALUEFUNC(_wrap_SimpleRenderable_get_world_transforms), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "_notify_current_camera", VALUEFUNC(_wrap_SimpleRenderable__notify_current_camera), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "set_bounding_box", VALUEFUNC(_wrap_SimpleRenderable_set_bounding_box), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "get_bounding_box", VALUEFUNC(_wrap_SimpleRenderable_get_bounding_box), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "_update_render_queue", VALUEFUNC(_wrap_SimpleRenderable__update_render_queue), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "visit_renderables", VALUEFUNC(_wrap_SimpleRenderable_visit_renderables), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "get_movable_type", VALUEFUNC(_wrap_SimpleRenderable_get_movable_type), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "get_lights", VALUEFUNC(_wrap_SimpleRenderable_get_lights), -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, "get_num_animations", VALUEFUNC(_wrap_SkeletonInstance_get_num_animations), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "_get_animation_impl", VALUEFUNC(_wrap_SkeletonInstance__get_animation_impl), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "create_animation", VALUEFUNC(_wrap_SkeletonInstance_create_animation), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "get_animation", VALUEFUNC(_wrap_SkeletonInstance_get_animation), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "remove_animation", VALUEFUNC(_wrap_SkeletonInstance_remove_animation), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "create_tag_point_on_bone", VALUEFUNC(_wrap_SkeletonInstance_create_tag_point_on_bone), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "free_tag_point", VALUEFUNC(_wrap_SkeletonInstance_free_tag_point), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "add_linked_skeleton_animation_source", VALUEFUNC(_wrap_SkeletonInstance_add_linked_skeleton_animation_source), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "remove_all_linked_skeleton_animation_sources", VALUEFUNC(_wrap_SkeletonInstance_remove_all_linked_skeleton_animation_sources), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "get_linked_skeleton_animation_source_iterator", VALUEFUNC(_wrap_SkeletonInstance_get_linked_skeleton_animation_source_iterator), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "_init_animation_state", VALUEFUNC(_wrap_SkeletonInstance__init_animation_state), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "_refresh_animation_state", VALUEFUNC(_wrap_SkeletonInstance__refresh_animation_state), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "get_name", VALUEFUNC(_wrap_SkeletonInstance_get_name), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "get_handle", VALUEFUNC(_wrap_SkeletonInstance_get_handle), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "get_group", VALUEFUNC(_wrap_SkeletonInstance_get_group), -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, "get_name", VALUEFUNC(_wrap_InstancedGeometry_get_name), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "add_entity", VALUEFUNC(_wrap_InstancedGeometry_add_entity), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "add_scene_node", VALUEFUNC(_wrap_InstancedGeometry_add_scene_node), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "build", VALUEFUNC(_wrap_InstancedGeometry_build), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "add_batch_instance", VALUEFUNC(_wrap_InstancedGeometry_add_batch_instance), -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, "set_rendering_distance", VALUEFUNC(_wrap_InstancedGeometry_set_rendering_distance), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_rendering_distance", VALUEFUNC(_wrap_InstancedGeometry_get_rendering_distance), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_squared_rendering_distance", VALUEFUNC(_wrap_InstancedGeometry_get_squared_rendering_distance), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "set_visible", VALUEFUNC(_wrap_InstancedGeometry_set_visible), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "is_visible", VALUEFUNC(_wrap_InstancedGeometry_is_visible), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "set_cast_shadows", VALUEFUNC(_wrap_InstancedGeometry_set_cast_shadows), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_cast_shadows", VALUEFUNC(_wrap_InstancedGeometry_get_cast_shadows), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "set_batch_instance_dimensions", VALUEFUNC(_wrap_InstancedGeometry_set_batch_instance_dimensions), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_batch_instance_dimensions", VALUEFUNC(_wrap_InstancedGeometry_get_batch_instance_dimensions), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "set_origin", VALUEFUNC(_wrap_InstancedGeometry_set_origin), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_origin", VALUEFUNC(_wrap_InstancedGeometry_get_origin), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "set_render_queue_group", VALUEFUNC(_wrap_InstancedGeometry_set_render_queue_group), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_render_queue_group", VALUEFUNC(_wrap_InstancedGeometry_get_render_queue_group), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_batch_instance_iterator", VALUEFUNC(_wrap_InstancedGeometry_get_batch_instance_iterator), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_render_operation_vector", VALUEFUNC(_wrap_InstancedGeometry_get_render_operation_vector), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "visit_renderables", VALUEFUNC(_wrap_InstancedGeometry_visit_renderables), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "dump", VALUEFUNC(_wrap_InstancedGeometry_dump), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_base_skeleton_instance", VALUEFUNC(_wrap_InstancedGeometry_get_base_skeleton_instance), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_base_skeleton", VALUEFUNC(_wrap_InstancedGeometry_get_base_skeleton), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_base_animation_state", VALUEFUNC(_wrap_InstancedGeometry_get_base_animation_state), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_object_count", VALUEFUNC(_wrap_InstancedGeometry_get_object_count), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "set_provide_world_inverses", VALUEFUNC(_wrap_InstancedGeometry_set_provide_world_inverses), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "get_provide_world_inverses", VALUEFUNC(_wrap_InstancedGeometry_get_provide_world_inverses), -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, "prequeue_movable_object_lod_changed", VALUEFUNC(_wrap_LodListener_prequeue_movable_object_lod_changed), -1);
  rb_define_method(SwigClassLodListener.klass, "postqueue_movable_object_lod_changed", VALUEFUNC(_wrap_LodListener_postqueue_movable_object_lod_changed), -1);
  rb_define_method(SwigClassLodListener.klass, "prequeue_entity_mesh_lod_changed", VALUEFUNC(_wrap_LodListener_prequeue_entity_mesh_lod_changed), -1);
  rb_define_method(SwigClassLodListener.klass, "postqueue_entity_mesh_lod_changed", VALUEFUNC(_wrap_LodListener_postqueue_entity_mesh_lod_changed), -1);
  rb_define_method(SwigClassLodListener.klass, "prequeue_entity_material_lod_changed", VALUEFUNC(_wrap_LodListener_prequeue_entity_material_lod_changed), -1);
  rb_define_method(SwigClassLodListener.klass, "postqueue_entity_material_lod_changed", VALUEFUNC(_wrap_LodListener_postqueue_entity_material_lod_changed), -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, "add_strategy", VALUEFUNC(_wrap_LodStrategyManager_add_strategy), -1);
  rb_define_method(SwigClassLodStrategyManager.klass, "remove_strategy", VALUEFUNC(_wrap_LodStrategyManager_remove_strategy), -1);
  rb_define_method(SwigClassLodStrategyManager.klass, "remove_all_strategies", VALUEFUNC(_wrap_LodStrategyManager_remove_all_strategies), -1);
  rb_define_method(SwigClassLodStrategyManager.klass, "get_strategy", VALUEFUNC(_wrap_LodStrategyManager_get_strategy), -1);
  rb_define_method(SwigClassLodStrategyManager.klass, "set_default_strategy", VALUEFUNC(_wrap_LodStrategyManager_set_default_strategy), -1);
  rb_define_method(SwigClassLodStrategyManager.klass, "get_default_strategy", VALUEFUNC(_wrap_LodStrategyManager_get_default_strategy), -1);
  rb_define_singleton_method(SwigClassLodStrategyManager.klass, "get_singleton", VALUEFUNC(_wrap_LodStrategyManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassLodStrategyManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_LodStrategyManager_get_singleton_ptr), -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, "estimate_vertex_count", VALUEFUNC(_wrap_ManualObject_estimate_vertex_count), -1);
  rb_define_method(SwigClassManualObject.klass, "estimate_index_count", VALUEFUNC(_wrap_ManualObject_estimate_index_count), -1);
  rb_define_method(SwigClassManualObject.klass, "begin", VALUEFUNC(_wrap_ManualObject_begin), -1);
  rb_define_method(SwigClassManualObject.klass, "set_dynamic", VALUEFUNC(_wrap_ManualObject_set_dynamic), -1);
  rb_define_method(SwigClassManualObject.klass, "get_dynamic", VALUEFUNC(_wrap_ManualObject_get_dynamic), -1);
  rb_define_method(SwigClassManualObject.klass, "begin_update", VALUEFUNC(_wrap_ManualObject_begin_update), -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, "texture_coord", VALUEFUNC(_wrap_ManualObject_texture_coord), -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, "get_current_vertex_count", VALUEFUNC(_wrap_ManualObject_get_current_vertex_count), -1);
  rb_define_method(SwigClassManualObject.klass, "get_current_index_count", VALUEFUNC(_wrap_ManualObject_get_current_index_count), -1);
  rb_define_method(SwigClassManualObject.klass, "end", VALUEFUNC(_wrap_ManualObject_end), -1);
  rb_define_method(SwigClassManualObject.klass, "set_material_name", VALUEFUNC(_wrap_ManualObject_set_material_name), -1);
  rb_define_method(SwigClassManualObject.klass, "convert_to_mesh", VALUEFUNC(_wrap_ManualObject_convert_to_mesh), -1);
  rb_define_method(SwigClassManualObject.klass, "set_use_identity_projection", VALUEFUNC(_wrap_ManualObject_set_use_identity_projection), -1);
  rb_define_method(SwigClassManualObject.klass, "get_use_identity_projection", VALUEFUNC(_wrap_ManualObject_get_use_identity_projection), -1);
  rb_define_method(SwigClassManualObject.klass, "set_use_identity_view", VALUEFUNC(_wrap_ManualObject_set_use_identity_view), -1);
  rb_define_method(SwigClassManualObject.klass, "get_use_identity_view", VALUEFUNC(_wrap_ManualObject_get_use_identity_view), -1);
  rb_define_method(SwigClassManualObject.klass, "set_bounding_box", VALUEFUNC(_wrap_ManualObject_set_bounding_box), -1);
  rb_define_method(SwigClassManualObject.klass, "get_section", VALUEFUNC(_wrap_ManualObject_get_section), -1);
  rb_define_method(SwigClassManualObject.klass, "get_num_sections", VALUEFUNC(_wrap_ManualObject_get_num_sections), -1);
  rb_define_method(SwigClassManualObject.klass, "set_keep_declaration_order", VALUEFUNC(_wrap_ManualObject_set_keep_declaration_order), -1);
  rb_define_method(SwigClassManualObject.klass, "get_keep_declaration_order", VALUEFUNC(_wrap_ManualObject_get_keep_declaration_order), -1);
  rb_define_method(SwigClassManualObject.klass, "get_movable_type", VALUEFUNC(_wrap_ManualObject_get_movable_type), -1);
  rb_define_method(SwigClassManualObject.klass, "get_bounding_box", VALUEFUNC(_wrap_ManualObject_get_bounding_box), -1);
  rb_define_method(SwigClassManualObject.klass, "get_bounding_radius", VALUEFUNC(_wrap_ManualObject_get_bounding_radius), -1);
  rb_define_method(SwigClassManualObject.klass, "_update_render_queue", VALUEFUNC(_wrap_ManualObject__update_render_queue), -1);
  rb_define_method(SwigClassManualObject.klass, "get_edge_list", VALUEFUNC(_wrap_ManualObject_get_edge_list), -1);
  rb_define_method(SwigClassManualObject.klass, "has_edge_list", VALUEFUNC(_wrap_ManualObject_has_edge_list), -1);
  rb_define_method(SwigClassManualObject.klass, "get_shadow_volume_renderable_iterator", VALUEFUNC(_wrap_ManualObject_get_shadow_volume_renderable_iterator), -1);
  rb_define_method(SwigClassManualObject.klass, "visit_renderables", VALUEFUNC(_wrap_ManualObject_visit_renderables), -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, "get_type", VALUEFUNC(_wrap_ManualObjectFactory_get_type), -1);
  rb_define_method(SwigClassManualObjectFactory.klass, "destroy_instance", VALUEFUNC(_wrap_ManualObjectFactory_destroy_instance), -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, "alloc_bytes", VALUEFUNC(_wrap_NedPoolingImpl_alloc_bytes), -1);
  rb_define_singleton_method(SwigClassNedPoolingImpl.klass, "dealloc_bytes", VALUEFUNC(_wrap_NedPoolingImpl_dealloc_bytes), -1);
  rb_define_singleton_method(SwigClassNedPoolingImpl.klass, "alloc_bytes_aligned", VALUEFUNC(_wrap_NedPoolingImpl_alloc_bytes_aligned), -1);
  rb_define_singleton_method(SwigClassNedPoolingImpl.klass, "dealloc_bytes_aligned", VALUEFUNC(_wrap_NedPoolingImpl_dealloc_bytes_aligned), -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, "allocate_bytes", VALUEFUNC(_wrap_NedPoolingPolicy_allocate_bytes), -1);
  rb_define_singleton_method(SwigClassNedPoolingPolicy.klass, "deallocate_bytes", VALUEFUNC(_wrap_NedPoolingPolicy_deallocate_bytes), -1);
  rb_define_singleton_method(SwigClassNedPoolingPolicy.klass, "get_max_allocation_size", VALUEFUNC(_wrap_NedPoolingPolicy_get_max_allocation_size), -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, "define_surface", VALUEFUNC(_wrap_PatchSurface_define_surface), -1);
  rb_define_method(SwigClassPatchSurface.klass, "get_required_vertex_count", VALUEFUNC(_wrap_PatchSurface_get_required_vertex_count), -1);
  rb_define_method(SwigClassPatchSurface.klass, "get_required_index_count", VALUEFUNC(_wrap_PatchSurface_get_required_index_count), -1);
  rb_define_method(SwigClassPatchSurface.klass, "get_current_index_count", VALUEFUNC(_wrap_PatchSurface_get_current_index_count), -1);
  rb_define_method(SwigClassPatchSurface.klass, "get_index_offset", VALUEFUNC(_wrap_PatchSurface_get_index_offset), -1);
  rb_define_method(SwigClassPatchSurface.klass, "get_vertex_offset", VALUEFUNC(_wrap_PatchSurface_get_vertex_offset), -1);
  rb_define_method(SwigClassPatchSurface.klass, "get_bounds", VALUEFUNC(_wrap_PatchSurface_get_bounds), -1);
  rb_define_method(SwigClassPatchSurface.klass, "get_bounding_sphere_radius", VALUEFUNC(_wrap_PatchSurface_get_bounding_sphere_radius), -1);
  rb_define_method(SwigClassPatchSurface.klass, "build", VALUEFUNC(_wrap_PatchSurface_build), -1);
  rb_define_method(SwigClassPatchSurface.klass, "set_subdivision_factor", VALUEFUNC(_wrap_PatchSurface_set_subdivision_factor), -1);
  rb_define_method(SwigClassPatchSurface.klass, "get_subdivision_factor", VALUEFUNC(_wrap_PatchSurface_get_subdivision_factor), -1);
  rb_define_method(SwigClassPatchSurface.klass, "get_control_point_buffer", VALUEFUNC(_wrap_PatchSurface_get_control_point_buffer), -1);
  rb_define_method(SwigClassPatchSurface.klass, "notify_control_point_buffer_deallocated", VALUEFUNC(_wrap_PatchSurface_notify_control_point_buffer_deallocated), -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, "set_subdivision", VALUEFUNC(_wrap_PatchMesh_set_subdivision), -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, "create_or_retrieve", VALUEFUNC(_wrap_MeshManager_create_or_retrieve), -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, "create_manual", VALUEFUNC(_wrap_MeshManager_create_manual), -1);
  rb_define_method(SwigClassMeshManager.klass, "create_plane", VALUEFUNC(_wrap_MeshManager_create_plane), -1);
  rb_define_method(SwigClassMeshManager.klass, "create_curved_illusion_plane", VALUEFUNC(_wrap_MeshManager_create_curved_illusion_plane), -1);
  rb_define_method(SwigClassMeshManager.klass, "create_curved_plane", VALUEFUNC(_wrap_MeshManager_create_curved_plane), -1);
  rb_define_method(SwigClassMeshManager.klass, "create_bezier_patch", VALUEFUNC(_wrap_MeshManager_create_bezier_patch), -1);
  rb_define_method(SwigClassMeshManager.klass, "set_prepare_all_meshes_for_shadow_volumes", VALUEFUNC(_wrap_MeshManager_set_prepare_all_meshes_for_shadow_volumes), -1);
  rb_define_method(SwigClassMeshManager.klass, "get_prepare_all_meshes_for_shadow_volumes", VALUEFUNC(_wrap_MeshManager_get_prepare_all_meshes_for_shadow_volumes), -1);
  rb_define_singleton_method(SwigClassMeshManager.klass, "get_singleton", VALUEFUNC(_wrap_MeshManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassMeshManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_MeshManager_get_singleton_ptr), -1);
  rb_define_method(SwigClassMeshManager.klass, "get_bounds_padding_factor", VALUEFUNC(_wrap_MeshManager_get_bounds_padding_factor), -1);
  rb_define_method(SwigClassMeshManager.klass, "set_bounds_padding_factor", VALUEFUNC(_wrap_MeshManager_set_bounds_padding_factor), -1);
  rb_define_method(SwigClassMeshManager.klass, "set_listener", VALUEFUNC(_wrap_MeshManager_set_listener), -1);
  rb_define_method(SwigClassMeshManager.klass, "get_listener", VALUEFUNC(_wrap_MeshManager_get_listener), -1);
  rb_define_method(SwigClassMeshManager.klass, "load_resource", VALUEFUNC(_wrap_MeshManager_load_resource), -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, "export_mesh", VALUEFUNC(_wrap_MeshSerializer_export_mesh), -1);
  rb_define_method(SwigClassMeshSerializer.klass, "import_mesh", VALUEFUNC(_wrap_MeshSerializer_import_mesh), -1);
  rb_define_method(SwigClassMeshSerializer.klass, "set_listener", VALUEFUNC(_wrap_MeshSerializer_set_listener), -1);
  rb_define_method(SwigClassMeshSerializer.klass, "get_listener", VALUEFUNC(_wrap_MeshSerializer_get_listener), -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, "process_material_name", VALUEFUNC(_wrap_MeshSerializerListener_process_material_name), -1);
  rb_define_method(SwigClassMeshSerializerListener.klass, "process_skeleton_name", VALUEFUNC(_wrap_MeshSerializerListener_process_skeleton_name), -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, "get_implementation", VALUEFUNC(_wrap_OptimisedUtil_get_implementation), -1);
  rb_define_method(SwigClassOptimisedUtil.klass, "software_vertex_skinning", VALUEFUNC(_wrap_OptimisedUtil_software_vertex_skinning), -1);
  rb_define_method(SwigClassOptimisedUtil.klass, "software_vertex_morph", VALUEFUNC(_wrap_OptimisedUtil_software_vertex_morph), -1);
  rb_define_method(SwigClassOptimisedUtil.klass, "concatenate_affine_matrices", VALUEFUNC(_wrap_OptimisedUtil_concatenate_affine_matrices), -1);
  rb_define_method(SwigClassOptimisedUtil.klass, "calculate_face_normals", VALUEFUNC(_wrap_OptimisedUtil_calculate_face_normals), -1);
  rb_define_method(SwigClassOptimisedUtil.klass, "calculate_light_facing", VALUEFUNC(_wrap_OptimisedUtil_calculate_light_facing), -1);
  rb_define_method(SwigClassOptimisedUtil.klass, "extrude_vertices", VALUEFUNC(_wrap_OptimisedUtil_extrude_vertices), -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, "get_child", VALUEFUNC(_wrap_Overlay_get_child), -1);
  rb_define_method(SwigClassOverlay.klass, "get_name", VALUEFUNC(_wrap_Overlay_get_name), -1);
  rb_define_method(SwigClassOverlay.klass, "set_zorder", VALUEFUNC(_wrap_Overlay_set_zorder), -1);
  rb_define_method(SwigClassOverlay.klass, "get_zorder", VALUEFUNC(_wrap_Overlay_get_zorder), -1);
  rb_define_method(SwigClassOverlay.klass, "is_visible", VALUEFUNC(_wrap_Overlay_is_visible), -1);
  rb_define_method(SwigClassOverlay.klass, "is_initialised", VALUEFUNC(_wrap_Overlay_is_initialised), -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, "add_2d", VALUEFUNC(_wrap_Overlay_add_2d), -1);
  rb_define_method(SwigClassOverlay.klass, "remove_2d", VALUEFUNC(_wrap_Overlay_remove_2d), -1);
  rb_define_method(SwigClassOverlay.klass, "add_3d", VALUEFUNC(_wrap_Overlay_add_3d), -1);
  rb_define_method(SwigClassOverlay.klass, "remove_3d", VALUEFUNC(_wrap_Overlay_remove_3d), -1);
  rb_define_method(SwigClassOverlay.klass, "clear", VALUEFUNC(_wrap_Overlay_clear), -1);
  rb_define_method(SwigClassOverlay.klass, "set_scroll", VALUEFUNC(_wrap_Overlay_set_scroll), -1);
  rb_define_method(SwigClassOverlay.klass, "get_scroll_x", VALUEFUNC(_wrap_Overlay_get_scroll_x), -1);
  rb_define_method(SwigClassOverlay.klass, "get_scroll_y", VALUEFUNC(_wrap_Overlay_get_scroll_y), -1);
  rb_define_method(SwigClassOverlay.klass, "scroll", VALUEFUNC(_wrap_Overlay_scroll), -1);
  rb_define_method(SwigClassOverlay.klass, "set_rotate", VALUEFUNC(_wrap_Overlay_set_rotate), -1);
  rb_define_method(SwigClassOverlay.klass, "get_rotate", VALUEFUNC(_wrap_Overlay_get_rotate), -1);
  rb_define_method(SwigClassOverlay.klass, "rotate", VALUEFUNC(_wrap_Overlay_rotate), -1);
  rb_define_method(SwigClassOverlay.klass, "set_scale", VALUEFUNC(_wrap_Overlay_set_scale), -1);
  rb_define_method(SwigClassOverlay.klass, "get_scale_x", VALUEFUNC(_wrap_Overlay_get_scale_x), -1);
  rb_define_method(SwigClassOverlay.klass, "get_scale_y", VALUEFUNC(_wrap_Overlay_get_scale_y), -1);
  rb_define_method(SwigClassOverlay.klass, "_get_world_transforms", VALUEFUNC(_wrap_Overlay__get_world_transforms), -1);
  rb_define_method(SwigClassOverlay.klass, "_find_visible_objects", VALUEFUNC(_wrap_Overlay__find_visible_objects), -1);
  rb_define_method(SwigClassOverlay.klass, "find_element_at", VALUEFUNC(_wrap_Overlay_find_element_at), -1);
  rb_define_method(SwigClassOverlay.klass, "get_2delements_iterator", VALUEFUNC(_wrap_Overlay_get_2delements_iterator), -1);
  rb_define_method(SwigClassOverlay.klass, "get_origin", VALUEFUNC(_wrap_Overlay_get_origin), -1);
  rb_define_method(SwigClassOverlay.klass, "_notify_origin", VALUEFUNC(_wrap_Overlay__notify_origin), -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, "set_caption", VALUEFUNC(_wrap_TextAreaOverlayElement_set_caption), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "set_char_height", VALUEFUNC(_wrap_TextAreaOverlayElement_set_char_height), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "get_char_height", VALUEFUNC(_wrap_TextAreaOverlayElement_get_char_height), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "set_space_width", VALUEFUNC(_wrap_TextAreaOverlayElement_set_space_width), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "get_space_width", VALUEFUNC(_wrap_TextAreaOverlayElement_get_space_width), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "set_font_name", VALUEFUNC(_wrap_TextAreaOverlayElement_set_font_name), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "get_font_name", VALUEFUNC(_wrap_TextAreaOverlayElement_get_font_name), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "get_type_name", VALUEFUNC(_wrap_TextAreaOverlayElement_get_type_name), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "get_material", VALUEFUNC(_wrap_TextAreaOverlayElement_get_material), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "get_render_operation", VALUEFUNC(_wrap_TextAreaOverlayElement_get_render_operation), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "set_material_name", VALUEFUNC(_wrap_TextAreaOverlayElement_set_material_name), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "set_colour", VALUEFUNC(_wrap_TextAreaOverlayElement_set_colour), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "get_colour", VALUEFUNC(_wrap_TextAreaOverlayElement_get_colour), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "set_colour_bottom", VALUEFUNC(_wrap_TextAreaOverlayElement_set_colour_bottom), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "get_colour_bottom", VALUEFUNC(_wrap_TextAreaOverlayElement_get_colour_bottom), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "set_colour_top", VALUEFUNC(_wrap_TextAreaOverlayElement_set_colour_top), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "get_colour_top", VALUEFUNC(_wrap_TextAreaOverlayElement_get_colour_top), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "set_alignment", VALUEFUNC(_wrap_TextAreaOverlayElement_set_alignment), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "get_alignment", VALUEFUNC(_wrap_TextAreaOverlayElement_get_alignment), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "set_metrics_mode", VALUEFUNC(_wrap_TextAreaOverlayElement_set_metrics_mode), -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, "create_overlay_element", VALUEFUNC(_wrap_OverlayElementFactory_create_overlay_element), -1);
  rb_define_method(SwigClassOverlayElementFactory.klass, "destroy_overlay_element", VALUEFUNC(_wrap_OverlayElementFactory_destroy_overlay_element), -1);
  rb_define_method(SwigClassOverlayElementFactory.klass, "get_type_name", VALUEFUNC(_wrap_OverlayElementFactory_get_type_name), -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, "create_overlay_element", VALUEFUNC(_wrap_PanelOverlayElementFactory_create_overlay_element), -1);
  rb_define_method(SwigClassPanelOverlayElementFactory.klass, "get_type_name", VALUEFUNC(_wrap_PanelOverlayElementFactory_get_type_name), -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, "create_overlay_element", VALUEFUNC(_wrap_BorderPanelOverlayElementFactory_create_overlay_element), -1);
  rb_define_method(SwigClassBorderPanelOverlayElementFactory.klass, "get_type_name", VALUEFUNC(_wrap_BorderPanelOverlayElementFactory_get_type_name), -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, "create_overlay_element", VALUEFUNC(_wrap_TextAreaOverlayElementFactory_create_overlay_element), -1);
  rb_define_method(SwigClassTextAreaOverlayElementFactory.klass, "get_type_name", VALUEFUNC(_wrap_TextAreaOverlayElementFactory_get_type_name), -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, "get_script_patterns", VALUEFUNC(_wrap_OverlayManager_get_script_patterns), -1);
  rb_define_method(SwigClassOverlayManager.klass, "parse_script", VALUEFUNC(_wrap_OverlayManager_parse_script), -1);
  rb_define_method(SwigClassOverlayManager.klass, "get_loading_order", VALUEFUNC(_wrap_OverlayManager_get_loading_order), -1);
  rb_define_method(SwigClassOverlayManager.klass, "create", VALUEFUNC(_wrap_OverlayManager_create), -1);
  rb_define_method(SwigClassOverlayManager.klass, "get_by_name", VALUEFUNC(_wrap_OverlayManager_get_by_name), -1);
  rb_define_method(SwigClassOverlayManager.klass, "destroy", VALUEFUNC(_wrap_OverlayManager_destroy), -1);
  rb_define_method(SwigClassOverlayManager.klass, "destroy_all", VALUEFUNC(_wrap_OverlayManager_destroy_all), -1);
  rb_define_method(SwigClassOverlayManager.klass, "get_overlay_iterator", VALUEFUNC(_wrap_OverlayManager_get_overlay_iterator), -1);
  rb_define_method(SwigClassOverlayManager.klass, "_queue_overlays_for_rendering", VALUEFUNC(_wrap_OverlayManager__queue_overlays_for_rendering), -1);
  rb_define_method(SwigClassOverlayManager.klass, "has_viewport_changed", VALUEFUNC(_wrap_OverlayManager_has_viewport_changed), -1);
  rb_define_method(SwigClassOverlayManager.klass, "get_viewport_height", VALUEFUNC(_wrap_OverlayManager_get_viewport_height), -1);
  rb_define_method(SwigClassOverlayManager.klass, "get_viewport_width", VALUEFUNC(_wrap_OverlayManager_get_viewport_width), -1);
  rb_define_method(SwigClassOverlayManager.klass, "get_viewport_aspect_ratio", VALUEFUNC(_wrap_OverlayManager_get_viewport_aspect_ratio), -1);
  rb_define_method(SwigClassOverlayManager.klass, "get_viewport_orientation_mode", VALUEFUNC(_wrap_OverlayManager_get_viewport_orientation_mode), -1);
  rb_define_method(SwigClassOverlayManager.klass, "create_overlay_element", VALUEFUNC(_wrap_OverlayManager_create_overlay_element), -1);
  rb_define_method(SwigClassOverlayManager.klass, "get_overlay_element", VALUEFUNC(_wrap_OverlayManager_get_overlay_element), -1);
  rb_define_method(SwigClassOverlayManager.klass, "has_overlay_element", VALUEFUNC(_wrap_OverlayManager_has_overlay_element), -1);
  rb_define_method(SwigClassOverlayManager.klass, "destroy_overlay_element", VALUEFUNC(_wrap_OverlayManager_destroy_overlay_element), -1);
  rb_define_method(SwigClassOverlayManager.klass, "destroy_all_overlay_elements", VALUEFUNC(_wrap_OverlayManager_destroy_all_overlay_elements), -1);
  rb_define_method(SwigClassOverlayManager.klass, "add_overlay_element_factory", VALUEFUNC(_wrap_OverlayManager_add_overlay_element_factory), -1);
  rb_define_method(SwigClassOverlayManager.klass, "get_overlay_element_factory_map", VALUEFUNC(_wrap_OverlayManager_get_overlay_element_factory_map), -1);
  rb_define_method(SwigClassOverlayManager.klass, "create_overlay_element_from_template", VALUEFUNC(_wrap_OverlayManager_create_overlay_element_from_template), -1);
  rb_define_method(SwigClassOverlayManager.klass, "clone_overlay_element_from_template", VALUEFUNC(_wrap_OverlayManager_clone_overlay_element_from_template), -1);
  rb_define_method(SwigClassOverlayManager.klass, "create_overlay_element_from_factory", VALUEFUNC(_wrap_OverlayManager_create_overlay_element_from_factory), -1);
  rb_define_method(SwigClassOverlayManager.klass, "get_template_iterator", VALUEFUNC(_wrap_OverlayManager_get_template_iterator), -1);
  rb_define_method(SwigClassOverlayManager.klass, "is_template", VALUEFUNC(_wrap_OverlayManager_is_template), -1);
  rb_define_singleton_method(SwigClassOverlayManager.klass, "get_singleton", VALUEFUNC(_wrap_OverlayManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassOverlayManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_OverlayManager_get_singleton_ptr), -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, "set_dimensions", VALUEFUNC(_wrap_Particle_set_dimensions), -1);
  rb_define_method(SwigClassParticle.klass, "has_own_dimensions", VALUEFUNC(_wrap_Particle_has_own_dimensions), -1);
  rb_define_method(SwigClassParticle.klass, "get_own_width", VALUEFUNC(_wrap_Particle_get_own_width), -1);
  rb_define_method(SwigClassParticle.klass, "get_own_height", VALUEFUNC(_wrap_Particle_get_own_height), -1);
  rb_define_method(SwigClassParticle.klass, "set_rotation", VALUEFUNC(_wrap_Particle_set_rotation), -1);
  rb_define_method(SwigClassParticle.klass, "get_rotation", VALUEFUNC(_wrap_Particle_get_rotation), -1);
  rb_define_method(SwigClassParticle.klass, "_notify_owner", VALUEFUNC(_wrap_Particle__notify_owner), -1);
  rb_define_method(SwigClassParticle.klass, "_notify_visual_data", VALUEFUNC(_wrap_Particle__notify_visual_data), -1);
  rb_define_method(SwigClassParticle.klass, "get_visual_data", VALUEFUNC(_wrap_Particle_get_visual_data), -1);
  rb_define_method(SwigClassParticle.klass, "reset_dimensions", VALUEFUNC(_wrap_Particle_reset_dimensions), -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, "_init_particle", VALUEFUNC(_wrap_ParticleAffector__init_particle), -1);
  rb_define_method(SwigClassParticleAffector.klass, "_affect_particles", VALUEFUNC(_wrap_ParticleAffector__affect_particles), -1);
  rb_define_method(SwigClassParticleAffector.klass, "get_type", VALUEFUNC(_wrap_ParticleAffector_get_type), -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, "get_name", VALUEFUNC(_wrap_ParticleAffectorFactory_get_name), -1);
  rb_define_method(SwigClassParticleAffectorFactory.klass, "create_affector", VALUEFUNC(_wrap_ParticleAffectorFactory_create_affector), -1);
  rb_define_method(SwigClassParticleAffectorFactory.klass, "destroy_affector", VALUEFUNC(_wrap_ParticleAffectorFactory_destroy_affector), -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, "do_get", VALUEFUNC(_wrap_CmdAngle_do_get), -1);
  rb_define_method(SwigClassCmdAngle.klass, "do_set", VALUEFUNC(_wrap_CmdAngle_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdColour_do_get), -1);
  rb_define_method(SwigClassCmdColour.klass, "do_set", VALUEFUNC(_wrap_CmdColour_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdColourRangeStart_do_get), -1);
  rb_define_method(SwigClassCmdColourRangeStart.klass, "do_set", VALUEFUNC(_wrap_CmdColourRangeStart_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdColourRangeEnd_do_get), -1);
  rb_define_method(SwigClassCmdColourRangeEnd.klass, "do_set", VALUEFUNC(_wrap_CmdColourRangeEnd_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdDirection_do_get), -1);
  rb_define_method(SwigClassCmdDirection.klass, "do_set", VALUEFUNC(_wrap_CmdDirection_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdUp_do_get), -1);
  rb_define_method(SwigClassCmdUp.klass, "do_set", VALUEFUNC(_wrap_CmdUp_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdEmissionRate_do_get), -1);
  rb_define_method(SwigClassCmdEmissionRate.klass, "do_set", VALUEFUNC(_wrap_CmdEmissionRate_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdVelocity_do_get), -1);
  rb_define_method(SwigClassCmdVelocity.klass, "do_set", VALUEFUNC(_wrap_CmdVelocity_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdMinVelocity_do_get), -1);
  rb_define_method(SwigClassCmdMinVelocity.klass, "do_set", VALUEFUNC(_wrap_CmdMinVelocity_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdMaxVelocity_do_get), -1);
  rb_define_method(SwigClassCmdMaxVelocity.klass, "do_set", VALUEFUNC(_wrap_CmdMaxVelocity_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdTTL_do_get), -1);
  rb_define_method(SwigClassCmdTTL.klass, "do_set", VALUEFUNC(_wrap_CmdTTL_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdMinTTL_do_get), -1);
  rb_define_method(SwigClassCmdMinTTL.klass, "do_set", VALUEFUNC(_wrap_CmdMinTTL_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdMaxTTL_do_get), -1);
  rb_define_method(SwigClassCmdMaxTTL.klass, "do_set", VALUEFUNC(_wrap_CmdMaxTTL_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdPosition_do_get), -1);
  rb_define_method(SwigClassCmdPosition.klass, "do_set", VALUEFUNC(_wrap_CmdPosition_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdDuration_do_get), -1);
  rb_define_method(SwigClassCmdDuration.klass, "do_set", VALUEFUNC(_wrap_CmdDuration_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdMinDuration_do_get), -1);
  rb_define_method(SwigClassCmdMinDuration.klass, "do_set", VALUEFUNC(_wrap_CmdMinDuration_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdMaxDuration_do_get), -1);
  rb_define_method(SwigClassCmdMaxDuration.klass, "do_set", VALUEFUNC(_wrap_CmdMaxDuration_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdRepeatDelay_do_get), -1);
  rb_define_method(SwigClassCmdRepeatDelay.klass, "do_set", VALUEFUNC(_wrap_CmdRepeatDelay_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdMinRepeatDelay_do_get), -1);
  rb_define_method(SwigClassCmdMinRepeatDelay.klass, "do_set", VALUEFUNC(_wrap_CmdMinRepeatDelay_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdMaxRepeatDelay_do_get), -1);
  rb_define_method(SwigClassCmdMaxRepeatDelay.klass, "do_set", VALUEFUNC(_wrap_CmdMaxRepeatDelay_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdName_do_get), -1);
  rb_define_method(SwigClassCmdName.klass, "do_set", VALUEFUNC(_wrap_CmdName_do_set), -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, "do_get", VALUEFUNC(_wrap_CmdEmittedEmitter_do_get), -1);
  rb_define_method(SwigClassCmdEmittedEmitter.klass, "do_set", VALUEFUNC(_wrap_CmdEmittedEmitter_do_set), -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, "set_position", VALUEFUNC(_wrap_ParticleEmitter_set_position), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_position", VALUEFUNC(_wrap_ParticleEmitter_get_position), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_direction", VALUEFUNC(_wrap_ParticleEmitter_set_direction), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_direction", VALUEFUNC(_wrap_ParticleEmitter_get_direction), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_up", VALUEFUNC(_wrap_ParticleEmitter_set_up), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_up", VALUEFUNC(_wrap_ParticleEmitter_get_up), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_angle", VALUEFUNC(_wrap_ParticleEmitter_set_angle), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_angle", VALUEFUNC(_wrap_ParticleEmitter_get_angle), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_particle_velocity", VALUEFUNC(_wrap_ParticleEmitter_set_particle_velocity), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_min_particle_velocity", VALUEFUNC(_wrap_ParticleEmitter_set_min_particle_velocity), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_max_particle_velocity", VALUEFUNC(_wrap_ParticleEmitter_set_max_particle_velocity), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_particle_velocity", VALUEFUNC(_wrap_ParticleEmitter_get_particle_velocity), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_min_particle_velocity", VALUEFUNC(_wrap_ParticleEmitter_get_min_particle_velocity), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_max_particle_velocity", VALUEFUNC(_wrap_ParticleEmitter_get_max_particle_velocity), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_emission_rate", VALUEFUNC(_wrap_ParticleEmitter_set_emission_rate), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_emission_rate", VALUEFUNC(_wrap_ParticleEmitter_get_emission_rate), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_time_to_live", VALUEFUNC(_wrap_ParticleEmitter_set_time_to_live), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_min_time_to_live", VALUEFUNC(_wrap_ParticleEmitter_set_min_time_to_live), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_max_time_to_live", VALUEFUNC(_wrap_ParticleEmitter_set_max_time_to_live), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_time_to_live", VALUEFUNC(_wrap_ParticleEmitter_get_time_to_live), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_min_time_to_live", VALUEFUNC(_wrap_ParticleEmitter_get_min_time_to_live), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_max_time_to_live", VALUEFUNC(_wrap_ParticleEmitter_get_max_time_to_live), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_colour", VALUEFUNC(_wrap_ParticleEmitter_set_colour), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_colour_range_start", VALUEFUNC(_wrap_ParticleEmitter_set_colour_range_start), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_colour_range_end", VALUEFUNC(_wrap_ParticleEmitter_set_colour_range_end), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_colour", VALUEFUNC(_wrap_ParticleEmitter_get_colour), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_colour_range_start", VALUEFUNC(_wrap_ParticleEmitter_get_colour_range_start), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_colour_range_end", VALUEFUNC(_wrap_ParticleEmitter_get_colour_range_end), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "_get_emission_count", VALUEFUNC(_wrap_ParticleEmitter__get_emission_count), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "_init_particle", VALUEFUNC(_wrap_ParticleEmitter__init_particle), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_type", VALUEFUNC(_wrap_ParticleEmitter_get_type), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_enabled", VALUEFUNC(_wrap_ParticleEmitter_set_enabled), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_enabled", VALUEFUNC(_wrap_ParticleEmitter_get_enabled), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_start_time", VALUEFUNC(_wrap_ParticleEmitter_set_start_time), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_start_time", VALUEFUNC(_wrap_ParticleEmitter_get_start_time), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_duration", VALUEFUNC(_wrap_ParticleEmitter_get_duration), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_duration", VALUEFUNC(_wrap_ParticleEmitter_set_duration), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_min_duration", VALUEFUNC(_wrap_ParticleEmitter_set_min_duration), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_max_duration", VALUEFUNC(_wrap_ParticleEmitter_set_max_duration), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_min_duration", VALUEFUNC(_wrap_ParticleEmitter_get_min_duration), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_max_duration", VALUEFUNC(_wrap_ParticleEmitter_get_max_duration), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_repeat_delay", VALUEFUNC(_wrap_ParticleEmitter_get_repeat_delay), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_repeat_delay", VALUEFUNC(_wrap_ParticleEmitter_set_repeat_delay), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_min_repeat_delay", VALUEFUNC(_wrap_ParticleEmitter_set_min_repeat_delay), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_max_repeat_delay", VALUEFUNC(_wrap_ParticleEmitter_set_max_repeat_delay), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_min_repeat_delay", VALUEFUNC(_wrap_ParticleEmitter_get_min_repeat_delay), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_max_repeat_delay", VALUEFUNC(_wrap_ParticleEmitter_get_max_repeat_delay), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_name", VALUEFUNC(_wrap_ParticleEmitter_get_name), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_name", VALUEFUNC(_wrap_ParticleEmitter_set_name), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "get_emitted_emitter", VALUEFUNC(_wrap_ParticleEmitter_get_emitted_emitter), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_emitted_emitter", VALUEFUNC(_wrap_ParticleEmitter_set_emitted_emitter), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "is_emitted", VALUEFUNC(_wrap_ParticleEmitter_is_emitted), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "set_emitted", VALUEFUNC(_wrap_ParticleEmitter_set_emitted), -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, "get_name", VALUEFUNC(_wrap_ParticleEmitterFactory_get_name), -1);
  rb_define_method(SwigClassParticleEmitterFactory.klass, "create_emitter", VALUEFUNC(_wrap_ParticleEmitterFactory_create_emitter), -1);
  rb_define_method(SwigClassParticleEmitterFactory.klass, "destroy_emitter", VALUEFUNC(_wrap_ParticleEmitterFactory_destroy_emitter), -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, "get_next", VALUEFUNC(_wrap_ParticleIterator_get_next), -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, "get_value", VALUEFUNC(_wrap_AbstractNode_get_value), -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, "get_value", VALUEFUNC(_wrap_AtomAbstractNode_get_value), -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, "get_value", VALUEFUNC(_wrap_ObjectAbstractNode_get_value), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "add_variable", VALUEFUNC(_wrap_ObjectAbstractNode_add_variable), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "set_variable", VALUEFUNC(_wrap_ObjectAbstractNode_set_variable), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "get_variable", VALUEFUNC(_wrap_ObjectAbstractNode_get_variable), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "get_variables", VALUEFUNC(_wrap_ObjectAbstractNode_get_variables), -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, "get_value", VALUEFUNC(_wrap_PropertyAbstractNode_get_value), -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, "get_value", VALUEFUNC(_wrap_ImportAbstractNode_get_value), -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, "get_value", VALUEFUNC(_wrap_VariableAccessAbstractNode_get_value), -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, "format_error_code", VALUEFUNC(_wrap_ScriptCompiler_format_error_code), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "compile", VALUEFUNC(_wrap_ScriptCompiler_compile), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "_generate_ast", VALUEFUNC(_wrap_ScriptCompiler__generate_ast), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "_compile", VALUEFUNC(_wrap_ScriptCompiler__compile), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "add_error", VALUEFUNC(_wrap_ScriptCompiler_add_error), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "set_listener", VALUEFUNC(_wrap_ScriptCompiler_set_listener), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "get_listener", VALUEFUNC(_wrap_ScriptCompiler_get_listener), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "get_resource_group", VALUEFUNC(_wrap_ScriptCompiler_get_resource_group), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "_fire_event", VALUEFUNC(_wrap_ScriptCompiler__fire_event), -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, "import_file", VALUEFUNC(_wrap_ScriptCompilerListener_import_file), -1);
  rb_define_method(SwigClassScriptCompilerListener.klass, "pre_conversion", VALUEFUNC(_wrap_ScriptCompilerListener_pre_conversion), -1);
  rb_define_method(SwigClassScriptCompilerListener.klass, "post_conversion", VALUEFUNC(_wrap_ScriptCompilerListener_post_conversion), -1);
  rb_define_method(SwigClassScriptCompilerListener.klass, "handle_error", VALUEFUNC(_wrap_ScriptCompilerListener_handle_error), -1);
  rb_define_method(SwigClassScriptCompilerListener.klass, "handle_event", VALUEFUNC(_wrap_ScriptCompilerListener_handle_event), -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, "set_listener", VALUEFUNC(_wrap_ScriptCompilerManager_set_listener), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "get_listener", VALUEFUNC(_wrap_ScriptCompilerManager_get_listener), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "add_translator_manager", VALUEFUNC(_wrap_ScriptCompilerManager_add_translator_manager), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "remove_translator_manager", VALUEFUNC(_wrap_ScriptCompilerManager_remove_translator_manager), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "clear_translator_managers", VALUEFUNC(_wrap_ScriptCompilerManager_clear_translator_managers), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "get_translator", VALUEFUNC(_wrap_ScriptCompilerManager_get_translator), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "add_script_pattern", VALUEFUNC(_wrap_ScriptCompilerManager_add_script_pattern), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "get_script_patterns", VALUEFUNC(_wrap_ScriptCompilerManager_get_script_patterns), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "parse_script", VALUEFUNC(_wrap_ScriptCompilerManager_parse_script), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "get_loading_order", VALUEFUNC(_wrap_ScriptCompilerManager_get_loading_order), -1);
  rb_define_singleton_method(SwigClassScriptCompilerManager.klass, "get_singleton", VALUEFUNC(_wrap_ScriptCompilerManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassScriptCompilerManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_ScriptCompilerManager_get_singleton_ptr), -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, "set_renderer", VALUEFUNC(_wrap_ParticleSystem_set_renderer), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_renderer", VALUEFUNC(_wrap_ParticleSystem_get_renderer), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_renderer_name", VALUEFUNC(_wrap_ParticleSystem_get_renderer_name), -1);
  rb_define_method(SwigClassParticleSystem.klass, "add_emitter", VALUEFUNC(_wrap_ParticleSystem_add_emitter), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_emitter", VALUEFUNC(_wrap_ParticleSystem_get_emitter), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_num_emitters", VALUEFUNC(_wrap_ParticleSystem_get_num_emitters), -1);
  rb_define_method(SwigClassParticleSystem.klass, "remove_emitter", VALUEFUNC(_wrap_ParticleSystem_remove_emitter), -1);
  rb_define_method(SwigClassParticleSystem.klass, "remove_all_emitters", VALUEFUNC(_wrap_ParticleSystem_remove_all_emitters), -1);
  rb_define_method(SwigClassParticleSystem.klass, "add_affector", VALUEFUNC(_wrap_ParticleSystem_add_affector), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_affector", VALUEFUNC(_wrap_ParticleSystem_get_affector), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_num_affectors", VALUEFUNC(_wrap_ParticleSystem_get_num_affectors), -1);
  rb_define_method(SwigClassParticleSystem.klass, "remove_affector", VALUEFUNC(_wrap_ParticleSystem_remove_affector), -1);
  rb_define_method(SwigClassParticleSystem.klass, "remove_all_affectors", VALUEFUNC(_wrap_ParticleSystem_remove_all_affectors), -1);
  rb_define_method(SwigClassParticleSystem.klass, "clear", VALUEFUNC(_wrap_ParticleSystem_clear), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_num_particles", VALUEFUNC(_wrap_ParticleSystem_get_num_particles), -1);
  rb_define_method(SwigClassParticleSystem.klass, "create_particle", VALUEFUNC(_wrap_ParticleSystem_create_particle), -1);
  rb_define_method(SwigClassParticleSystem.klass, "create_emitter_particle", VALUEFUNC(_wrap_ParticleSystem_create_emitter_particle), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_particle", VALUEFUNC(_wrap_ParticleSystem_get_particle), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_particle_quota", VALUEFUNC(_wrap_ParticleSystem_get_particle_quota), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_particle_quota", VALUEFUNC(_wrap_ParticleSystem_set_particle_quota), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_emitted_emitter_quota", VALUEFUNC(_wrap_ParticleSystem_get_emitted_emitter_quota), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_emitted_emitter_quota", VALUEFUNC(_wrap_ParticleSystem_set_emitted_emitter_quota), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_update", VALUEFUNC(_wrap_ParticleSystem__update), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_get_iterator", VALUEFUNC(_wrap_ParticleSystem__get_iterator), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_material_name", VALUEFUNC(_wrap_ParticleSystem_set_material_name), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_material_name", VALUEFUNC(_wrap_ParticleSystem_get_material_name), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_notify_current_camera", VALUEFUNC(_wrap_ParticleSystem__notify_current_camera), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_notify_attached", VALUEFUNC(_wrap_ParticleSystem__notify_attached), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_bounding_box", VALUEFUNC(_wrap_ParticleSystem_get_bounding_box), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_bounding_radius", VALUEFUNC(_wrap_ParticleSystem_get_bounding_radius), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_update_render_queue", VALUEFUNC(_wrap_ParticleSystem__update_render_queue), -1);
  rb_define_method(SwigClassParticleSystem.klass, "visit_renderables", VALUEFUNC(_wrap_ParticleSystem_visit_renderables), -1);
  rb_define_method(SwigClassParticleSystem.klass, "fast_forward", VALUEFUNC(_wrap_ParticleSystem_fast_forward), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_speed_factor", VALUEFUNC(_wrap_ParticleSystem_set_speed_factor), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_speed_factor", VALUEFUNC(_wrap_ParticleSystem_get_speed_factor), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_iteration_interval", VALUEFUNC(_wrap_ParticleSystem_set_iteration_interval), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_iteration_interval", VALUEFUNC(_wrap_ParticleSystem_get_iteration_interval), -1);
  rb_define_singleton_method(SwigClassParticleSystem.klass, "set_default_iteration_interval", VALUEFUNC(_wrap_ParticleSystem_set_default_iteration_interval), -1);
  rb_define_singleton_method(SwigClassParticleSystem.klass, "get_default_iteration_interval", VALUEFUNC(_wrap_ParticleSystem_get_default_iteration_interval), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_non_visible_update_timeout", VALUEFUNC(_wrap_ParticleSystem_set_non_visible_update_timeout), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_non_visible_update_timeout", VALUEFUNC(_wrap_ParticleSystem_get_non_visible_update_timeout), -1);
  rb_define_singleton_method(SwigClassParticleSystem.klass, "set_default_non_visible_update_timeout", VALUEFUNC(_wrap_ParticleSystem_set_default_non_visible_update_timeout), -1);
  rb_define_singleton_method(SwigClassParticleSystem.klass, "get_default_non_visible_update_timeout", VALUEFUNC(_wrap_ParticleSystem_get_default_non_visible_update_timeout), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_movable_type", VALUEFUNC(_wrap_ParticleSystem_get_movable_type), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_notify_particle_resized", VALUEFUNC(_wrap_ParticleSystem__notify_particle_resized), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_notify_particle_rotated", VALUEFUNC(_wrap_ParticleSystem__notify_particle_rotated), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_default_dimensions", VALUEFUNC(_wrap_ParticleSystem_set_default_dimensions), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_default_width", VALUEFUNC(_wrap_ParticleSystem_set_default_width), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_default_width", VALUEFUNC(_wrap_ParticleSystem_get_default_width), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_default_height", VALUEFUNC(_wrap_ParticleSystem_set_default_height), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_default_height", VALUEFUNC(_wrap_ParticleSystem_get_default_height), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_cull_individually", VALUEFUNC(_wrap_ParticleSystem_get_cull_individually), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_cull_individually", VALUEFUNC(_wrap_ParticleSystem_set_cull_individually), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_resource_group_name", VALUEFUNC(_wrap_ParticleSystem_get_resource_group_name), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_origin", VALUEFUNC(_wrap_ParticleSystem_get_origin), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_notify_origin", VALUEFUNC(_wrap_ParticleSystem__notify_origin), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_render_queue_group", VALUEFUNC(_wrap_ParticleSystem_set_render_queue_group), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_render_queue_group_and_priority", VALUEFUNC(_wrap_ParticleSystem_set_render_queue_group_and_priority), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_sorting_enabled", VALUEFUNC(_wrap_ParticleSystem_set_sorting_enabled), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_sorting_enabled", VALUEFUNC(_wrap_ParticleSystem_get_sorting_enabled), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_bounds", VALUEFUNC(_wrap_ParticleSystem_set_bounds), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_bounds_auto_updated", VALUEFUNC(_wrap_ParticleSystem_set_bounds_auto_updated), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_keep_particles_in_local_space", VALUEFUNC(_wrap_ParticleSystem_set_keep_particles_in_local_space), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_keep_particles_in_local_space", VALUEFUNC(_wrap_ParticleSystem_get_keep_particles_in_local_space), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_update_bounds", VALUEFUNC(_wrap_ParticleSystem__update_bounds), -1);
  rb_define_method(SwigClassParticleSystem.klass, "set_emitting", VALUEFUNC(_wrap_ParticleSystem_set_emitting), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_emitting", VALUEFUNC(_wrap_ParticleSystem_get_emitting), -1);
  rb_define_method(SwigClassParticleSystem.klass, "get_type_flags", VALUEFUNC(_wrap_ParticleSystem_get_type_flags), -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, "add_emitter_factory", VALUEFUNC(_wrap_ParticleSystemManager_add_emitter_factory), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "add_affector_factory", VALUEFUNC(_wrap_ParticleSystemManager_add_affector_factory), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "add_renderer_factory", VALUEFUNC(_wrap_ParticleSystemManager_add_renderer_factory), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "add_template", VALUEFUNC(_wrap_ParticleSystemManager_add_template), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "remove_template", VALUEFUNC(_wrap_ParticleSystemManager_remove_template), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "remove_all_templates", VALUEFUNC(_wrap_ParticleSystemManager_remove_all_templates), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "remove_templates_by_resource_group", VALUEFUNC(_wrap_ParticleSystemManager_remove_templates_by_resource_group), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "create_template", VALUEFUNC(_wrap_ParticleSystemManager_create_template), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "get_template", VALUEFUNC(_wrap_ParticleSystemManager_get_template), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_create_emitter", VALUEFUNC(_wrap_ParticleSystemManager__create_emitter), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_destroy_emitter", VALUEFUNC(_wrap_ParticleSystemManager__destroy_emitter), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_create_affector", VALUEFUNC(_wrap_ParticleSystemManager__create_affector), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_destroy_affector", VALUEFUNC(_wrap_ParticleSystemManager__destroy_affector), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_create_renderer", VALUEFUNC(_wrap_ParticleSystemManager__create_renderer), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_destroy_renderer", VALUEFUNC(_wrap_ParticleSystemManager__destroy_renderer), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_initialise", VALUEFUNC(_wrap_ParticleSystemManager__initialise), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "get_script_patterns", VALUEFUNC(_wrap_ParticleSystemManager_get_script_patterns), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "parse_script", VALUEFUNC(_wrap_ParticleSystemManager_parse_script), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "get_loading_order", VALUEFUNC(_wrap_ParticleSystemManager_get_loading_order), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "get_affector_factory_iterator", VALUEFUNC(_wrap_ParticleSystemManager_get_affector_factory_iterator), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "get_emitter_factory_iterator", VALUEFUNC(_wrap_ParticleSystemManager_get_emitter_factory_iterator), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "get_renderer_factory_iterator", VALUEFUNC(_wrap_ParticleSystemManager_get_renderer_factory_iterator), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "get_template_iterator", VALUEFUNC(_wrap_ParticleSystemManager_get_template_iterator), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_get_factory", VALUEFUNC(_wrap_ParticleSystemManager__get_factory), -1);
  rb_define_singleton_method(SwigClassParticleSystemManager.klass, "get_singleton", VALUEFUNC(_wrap_ParticleSystemManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassParticleSystemManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_ParticleSystemManager_get_singleton_ptr), -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, "get_type", VALUEFUNC(_wrap_ParticleSystemFactory_get_type), -1);
  rb_define_method(SwigClassParticleSystemFactory.klass, "destroy_instance", VALUEFUNC(_wrap_ParticleSystemFactory_destroy_instance), -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, "is_programmable", VALUEFUNC(_wrap_Pass_is_programmable), -1);
  rb_define_method(SwigClassPass.klass, "has_vertex_program", VALUEFUNC(_wrap_Pass_has_vertex_program), -1);
  rb_define_method(SwigClassPass.klass, "has_fragment_program", VALUEFUNC(_wrap_Pass_has_fragment_program), -1);
  rb_define_method(SwigClassPass.klass, "has_geometry_program", VALUEFUNC(_wrap_Pass_has_geometry_program), -1);
  rb_define_method(SwigClassPass.klass, "has_shadow_caster_vertex_program", VALUEFUNC(_wrap_Pass_has_shadow_caster_vertex_program), -1);
  rb_define_method(SwigClassPass.klass, "has_shadow_caster_fragment_program", VALUEFUNC(_wrap_Pass_has_shadow_caster_fragment_program), -1);
  rb_define_method(SwigClassPass.klass, "has_shadow_receiver_vertex_program", VALUEFUNC(_wrap_Pass_has_shadow_receiver_vertex_program), -1);
  rb_define_method(SwigClassPass.klass, "has_shadow_receiver_fragment_program", VALUEFUNC(_wrap_Pass_has_shadow_receiver_fragment_program), -1);
  rb_define_method(SwigClassPass.klass, "get_index", VALUEFUNC(_wrap_Pass_get_index), -1);
  rb_define_method(SwigClassPass.klass, "set_name", VALUEFUNC(_wrap_Pass_set_name), -1);
  rb_define_method(SwigClassPass.klass, "get_name", VALUEFUNC(_wrap_Pass_get_name), -1);
  rb_define_method(SwigClassPass.klass, "set_ambient", VALUEFUNC(_wrap_Pass_set_ambient), -1);
  rb_define_method(SwigClassPass.klass, "set_diffuse", VALUEFUNC(_wrap_Pass_set_diffuse), -1);
  rb_define_method(SwigClassPass.klass, "set_specular", VALUEFUNC(_wrap_Pass_set_specular), -1);
  rb_define_method(SwigClassPass.klass, "set_shininess", VALUEFUNC(_wrap_Pass_set_shininess), -1);
  rb_define_method(SwigClassPass.klass, "set_self_illumination", VALUEFUNC(_wrap_Pass_set_self_illumination), -1);
  rb_define_method(SwigClassPass.klass, "set_emissive", VALUEFUNC(_wrap_Pass_set_emissive), -1);
  rb_define_method(SwigClassPass.klass, "set_vertex_colour_tracking", VALUEFUNC(_wrap_Pass_set_vertex_colour_tracking), -1);
  rb_define_method(SwigClassPass.klass, "get_point_size", VALUEFUNC(_wrap_Pass_get_point_size), -1);
  rb_define_method(SwigClassPass.klass, "set_point_size", VALUEFUNC(_wrap_Pass_set_point_size), -1);
  rb_define_method(SwigClassPass.klass, "set_point_sprites_enabled", VALUEFUNC(_wrap_Pass_set_point_sprites_enabled), -1);
  rb_define_method(SwigClassPass.klass, "get_point_sprites_enabled", VALUEFUNC(_wrap_Pass_get_point_sprites_enabled), -1);
  rb_define_method(SwigClassPass.klass, "set_point_attenuation", VALUEFUNC(_wrap_Pass_set_point_attenuation), -1);
  rb_define_method(SwigClassPass.klass, "is_point_attenuation_enabled", VALUEFUNC(_wrap_Pass_is_point_attenuation_enabled), -1);
  rb_define_method(SwigClassPass.klass, "get_point_attenuation_constant", VALUEFUNC(_wrap_Pass_get_point_attenuation_constant), -1);
  rb_define_method(SwigClassPass.klass, "get_point_attenuation_linear", VALUEFUNC(_wrap_Pass_get_point_attenuation_linear), -1);
  rb_define_method(SwigClassPass.klass, "get_point_attenuation_quadratic", VALUEFUNC(_wrap_Pass_get_point_attenuation_quadratic), -1);
  rb_define_method(SwigClassPass.klass, "set_point_min_size", VALUEFUNC(_wrap_Pass_set_point_min_size), -1);
  rb_define_method(SwigClassPass.klass, "get_point_min_size", VALUEFUNC(_wrap_Pass_get_point_min_size), -1);
  rb_define_method(SwigClassPass.klass, "set_point_max_size", VALUEFUNC(_wrap_Pass_set_point_max_size), -1);
  rb_define_method(SwigClassPass.klass, "get_point_max_size", VALUEFUNC(_wrap_Pass_get_point_max_size), -1);
  rb_define_method(SwigClassPass.klass, "get_ambient", VALUEFUNC(_wrap_Pass_get_ambient), -1);
  rb_define_method(SwigClassPass.klass, "get_diffuse", VALUEFUNC(_wrap_Pass_get_diffuse), -1);
  rb_define_method(SwigClassPass.klass, "get_specular", VALUEFUNC(_wrap_Pass_get_specular), -1);
  rb_define_method(SwigClassPass.klass, "get_self_illumination", VALUEFUNC(_wrap_Pass_get_self_illumination), -1);
  rb_define_method(SwigClassPass.klass, "get_emissive", VALUEFUNC(_wrap_Pass_get_emissive), -1);
  rb_define_method(SwigClassPass.klass, "get_shininess", VALUEFUNC(_wrap_Pass_get_shininess), -1);
  rb_define_method(SwigClassPass.klass, "get_vertex_colour_tracking", VALUEFUNC(_wrap_Pass_get_vertex_colour_tracking), -1);
  rb_define_method(SwigClassPass.klass, "create_texture_unit_state", VALUEFUNC(_wrap_Pass_create_texture_unit_state), -1);
  rb_define_method(SwigClassPass.klass, "add_texture_unit_state", VALUEFUNC(_wrap_Pass_add_texture_unit_state), -1);
  rb_define_method(SwigClassPass.klass, "get_texture_unit_state", VALUEFUNC(_wrap_Pass_get_texture_unit_state), -1);
  rb_define_method(SwigClassPass.klass, "get_texture_unit_state_index", VALUEFUNC(_wrap_Pass_get_texture_unit_state_index), -1);
  rb_define_method(SwigClassPass.klass, "get_texture_unit_state_iterator", VALUEFUNC(_wrap_Pass_get_texture_unit_state_iterator), -1);
  rb_define_method(SwigClassPass.klass, "remove_texture_unit_state", VALUEFUNC(_wrap_Pass_remove_texture_unit_state), -1);
  rb_define_method(SwigClassPass.klass, "remove_all_texture_unit_states", VALUEFUNC(_wrap_Pass_remove_all_texture_unit_states), -1);
  rb_define_method(SwigClassPass.klass, "get_num_texture_unit_states", VALUEFUNC(_wrap_Pass_get_num_texture_unit_states), -1);
  rb_define_method(SwigClassPass.klass, "set_scene_blending", VALUEFUNC(_wrap_Pass_set_scene_blending), -1);
  rb_define_method(SwigClassPass.klass, "set_separate_scene_blending", VALUEFUNC(_wrap_Pass_set_separate_scene_blending), -1);
  rb_define_method(SwigClassPass.klass, "has_separate_scene_blending", VALUEFUNC(_wrap_Pass_has_separate_scene_blending), -1);
  rb_define_method(SwigClassPass.klass, "get_source_blend_factor", VALUEFUNC(_wrap_Pass_get_source_blend_factor), -1);
  rb_define_method(SwigClassPass.klass, "get_dest_blend_factor", VALUEFUNC(_wrap_Pass_get_dest_blend_factor), -1);
  rb_define_method(SwigClassPass.klass, "get_source_blend_factor_alpha", VALUEFUNC(_wrap_Pass_get_source_blend_factor_alpha), -1);
  rb_define_method(SwigClassPass.klass, "get_dest_blend_factor_alpha", VALUEFUNC(_wrap_Pass_get_dest_blend_factor_alpha), -1);
  rb_define_method(SwigClassPass.klass, "set_scene_blending_operation", VALUEFUNC(_wrap_Pass_set_scene_blending_operation), -1);
  rb_define_method(SwigClassPass.klass, "set_separate_scene_blending_operation", VALUEFUNC(_wrap_Pass_set_separate_scene_blending_operation), -1);
  rb_define_method(SwigClassPass.klass, "has_separate_scene_blending_operations", VALUEFUNC(_wrap_Pass_has_separate_scene_blending_operations), -1);
  rb_define_method(SwigClassPass.klass, "get_scene_blending_operation", VALUEFUNC(_wrap_Pass_get_scene_blending_operation), -1);
  rb_define_method(SwigClassPass.klass, "get_scene_blending_operation_alpha", VALUEFUNC(_wrap_Pass_get_scene_blending_operation_alpha), -1);
  rb_define_method(SwigClassPass.klass, "is_transparent", VALUEFUNC(_wrap_Pass_is_transparent), -1);
  rb_define_method(SwigClassPass.klass, "set_depth_check_enabled", VALUEFUNC(_wrap_Pass_set_depth_check_enabled), -1);
  rb_define_method(SwigClassPass.klass, "get_depth_check_enabled", VALUEFUNC(_wrap_Pass_get_depth_check_enabled), -1);
  rb_define_method(SwigClassPass.klass, "set_depth_write_enabled", VALUEFUNC(_wrap_Pass_set_depth_write_enabled), -1);
  rb_define_method(SwigClassPass.klass, "get_depth_write_enabled", VALUEFUNC(_wrap_Pass_get_depth_write_enabled), -1);
  rb_define_method(SwigClassPass.klass, "set_depth_function", VALUEFUNC(_wrap_Pass_set_depth_function), -1);
  rb_define_method(SwigClassPass.klass, "get_depth_function", VALUEFUNC(_wrap_Pass_get_depth_function), -1);
  rb_define_method(SwigClassPass.klass, "set_colour_write_enabled", VALUEFUNC(_wrap_Pass_set_colour_write_enabled), -1);
  rb_define_method(SwigClassPass.klass, "get_colour_write_enabled", VALUEFUNC(_wrap_Pass_get_colour_write_enabled), -1);
  rb_define_method(SwigClassPass.klass, "set_culling_mode", VALUEFUNC(_wrap_Pass_set_culling_mode), -1);
  rb_define_method(SwigClassPass.klass, "get_culling_mode", VALUEFUNC(_wrap_Pass_get_culling_mode), -1);
  rb_define_method(SwigClassPass.klass, "set_manual_culling_mode", VALUEFUNC(_wrap_Pass_set_manual_culling_mode), -1);
  rb_define_method(SwigClassPass.klass, "get_manual_culling_mode", VALUEFUNC(_wrap_Pass_get_manual_culling_mode), -1);
  rb_define_method(SwigClassPass.klass, "set_lighting_enabled", VALUEFUNC(_wrap_Pass_set_lighting_enabled), -1);
  rb_define_method(SwigClassPass.klass, "get_lighting_enabled", VALUEFUNC(_wrap_Pass_get_lighting_enabled), -1);
  rb_define_method(SwigClassPass.klass, "set_max_simultaneous_lights", VALUEFUNC(_wrap_Pass_set_max_simultaneous_lights), -1);
  rb_define_method(SwigClassPass.klass, "get_max_simultaneous_lights", VALUEFUNC(_wrap_Pass_get_max_simultaneous_lights), -1);
  rb_define_method(SwigClassPass.klass, "set_start_light", VALUEFUNC(_wrap_Pass_set_start_light), -1);
  rb_define_method(SwigClassPass.klass, "get_start_light", VALUEFUNC(_wrap_Pass_get_start_light), -1);
  rb_define_method(SwigClassPass.klass, "set_light_mask", VALUEFUNC(_wrap_Pass_set_light_mask), -1);
  rb_define_method(SwigClassPass.klass, "get_light_mask", VALUEFUNC(_wrap_Pass_get_light_mask), -1);
  rb_define_method(SwigClassPass.klass, "set_shading_mode", VALUEFUNC(_wrap_Pass_set_shading_mode), -1);
  rb_define_method(SwigClassPass.klass, "get_shading_mode", VALUEFUNC(_wrap_Pass_get_shading_mode), -1);
  rb_define_method(SwigClassPass.klass, "set_polygon_mode", VALUEFUNC(_wrap_Pass_set_polygon_mode), -1);
  rb_define_method(SwigClassPass.klass, "get_polygon_mode", VALUEFUNC(_wrap_Pass_get_polygon_mode), -1);
  rb_define_method(SwigClassPass.klass, "set_polygon_mode_overrideable", VALUEFUNC(_wrap_Pass_set_polygon_mode_overrideable), -1);
  rb_define_method(SwigClassPass.klass, "get_polygon_mode_overrideable", VALUEFUNC(_wrap_Pass_get_polygon_mode_overrideable), -1);
  rb_define_method(SwigClassPass.klass, "set_fog", VALUEFUNC(_wrap_Pass_set_fog), -1);
  rb_define_method(SwigClassPass.klass, "get_fog_override", VALUEFUNC(_wrap_Pass_get_fog_override), -1);
  rb_define_method(SwigClassPass.klass, "get_fog_mode", VALUEFUNC(_wrap_Pass_get_fog_mode), -1);
  rb_define_method(SwigClassPass.klass, "get_fog_colour", VALUEFUNC(_wrap_Pass_get_fog_colour), -1);
  rb_define_method(SwigClassPass.klass, "get_fog_start", VALUEFUNC(_wrap_Pass_get_fog_start), -1);
  rb_define_method(SwigClassPass.klass, "get_fog_end", VALUEFUNC(_wrap_Pass_get_fog_end), -1);
  rb_define_method(SwigClassPass.klass, "get_fog_density", VALUEFUNC(_wrap_Pass_get_fog_density), -1);
  rb_define_method(SwigClassPass.klass, "set_depth_bias", VALUEFUNC(_wrap_Pass_set_depth_bias), -1);
  rb_define_method(SwigClassPass.klass, "get_depth_bias_constant", VALUEFUNC(_wrap_Pass_get_depth_bias_constant), -1);
  rb_define_method(SwigClassPass.klass, "get_depth_bias_slope_scale", VALUEFUNC(_wrap_Pass_get_depth_bias_slope_scale), -1);
  rb_define_method(SwigClassPass.klass, "set_iteration_depth_bias", VALUEFUNC(_wrap_Pass_set_iteration_depth_bias), -1);
  rb_define_method(SwigClassPass.klass, "get_iteration_depth_bias", VALUEFUNC(_wrap_Pass_get_iteration_depth_bias), -1);
  rb_define_method(SwigClassPass.klass, "set_alpha_reject_settings", VALUEFUNC(_wrap_Pass_set_alpha_reject_settings), -1);
  rb_define_method(SwigClassPass.klass, "set_alpha_reject_function", VALUEFUNC(_wrap_Pass_set_alpha_reject_function), -1);
  rb_define_method(SwigClassPass.klass, "set_alpha_reject_value", VALUEFUNC(_wrap_Pass_set_alpha_reject_value), -1);
  rb_define_method(SwigClassPass.klass, "get_alpha_reject_function", VALUEFUNC(_wrap_Pass_get_alpha_reject_function), -1);
  rb_define_method(SwigClassPass.klass, "get_alpha_reject_value", VALUEFUNC(_wrap_Pass_get_alpha_reject_value), -1);
  rb_define_method(SwigClassPass.klass, "set_alpha_to_coverage_enabled", VALUEFUNC(_wrap_Pass_set_alpha_to_coverage_enabled), -1);
  rb_define_method(SwigClassPass.klass, "is_alpha_to_coverage_enabled", VALUEFUNC(_wrap_Pass_is_alpha_to_coverage_enabled), -1);
  rb_define_method(SwigClassPass.klass, "set_transparent_sorting_enabled", VALUEFUNC(_wrap_Pass_set_transparent_sorting_enabled), -1);
  rb_define_method(SwigClassPass.klass, "get_transparent_sorting_enabled", VALUEFUNC(_wrap_Pass_get_transparent_sorting_enabled), -1);
  rb_define_method(SwigClassPass.klass, "set_transparent_sorting_forced", VALUEFUNC(_wrap_Pass_set_transparent_sorting_forced), -1);
  rb_define_method(SwigClassPass.klass, "get_transparent_sorting_forced", VALUEFUNC(_wrap_Pass_get_transparent_sorting_forced), -1);
  rb_define_method(SwigClassPass.klass, "set_iterate_per_light", VALUEFUNC(_wrap_Pass_set_iterate_per_light), -1);
  rb_define_method(SwigClassPass.klass, "get_iterate_per_light", VALUEFUNC(_wrap_Pass_get_iterate_per_light), -1);
  rb_define_method(SwigClassPass.klass, "get_run_only_for_one_light_type", VALUEFUNC(_wrap_Pass_get_run_only_for_one_light_type), -1);
  rb_define_method(SwigClassPass.klass, "get_only_light_type", VALUEFUNC(_wrap_Pass_get_only_light_type), -1);
  rb_define_method(SwigClassPass.klass, "set_light_count_per_iteration", VALUEFUNC(_wrap_Pass_set_light_count_per_iteration), -1);
  rb_define_method(SwigClassPass.klass, "get_light_count_per_iteration", VALUEFUNC(_wrap_Pass_get_light_count_per_iteration), -1);
  rb_define_method(SwigClassPass.klass, "get_parent", VALUEFUNC(_wrap_Pass_get_parent), -1);
  rb_define_method(SwigClassPass.klass, "get_resource_group", VALUEFUNC(_wrap_Pass_get_resource_group), -1);
  rb_define_method(SwigClassPass.klass, "set_vertex_program", VALUEFUNC(_wrap_Pass_set_vertex_program), -1);
  rb_define_method(SwigClassPass.klass, "set_vertex_program_parameters", VALUEFUNC(_wrap_Pass_set_vertex_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_vertex_program_name", VALUEFUNC(_wrap_Pass_get_vertex_program_name), -1);
  rb_define_method(SwigClassPass.klass, "get_vertex_program_parameters", VALUEFUNC(_wrap_Pass_get_vertex_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_vertex_program", VALUEFUNC(_wrap_Pass_get_vertex_program), -1);
  rb_define_method(SwigClassPass.klass, "set_shadow_caster_vertex_program", VALUEFUNC(_wrap_Pass_set_shadow_caster_vertex_program), -1);
  rb_define_method(SwigClassPass.klass, "set_shadow_caster_vertex_program_parameters", VALUEFUNC(_wrap_Pass_set_shadow_caster_vertex_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_shadow_caster_vertex_program_name", VALUEFUNC(_wrap_Pass_get_shadow_caster_vertex_program_name), -1);
  rb_define_method(SwigClassPass.klass, "get_shadow_caster_vertex_program_parameters", VALUEFUNC(_wrap_Pass_get_shadow_caster_vertex_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_shadow_caster_vertex_program", VALUEFUNC(_wrap_Pass_get_shadow_caster_vertex_program), -1);
  rb_define_method(SwigClassPass.klass, "set_shadow_caster_fragment_program", VALUEFUNC(_wrap_Pass_set_shadow_caster_fragment_program), -1);
  rb_define_method(SwigClassPass.klass, "set_shadow_caster_fragment_program_parameters", VALUEFUNC(_wrap_Pass_set_shadow_caster_fragment_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_shadow_caster_fragment_program_name", VALUEFUNC(_wrap_Pass_get_shadow_caster_fragment_program_name), -1);
  rb_define_method(SwigClassPass.klass, "get_shadow_caster_fragment_program_parameters", VALUEFUNC(_wrap_Pass_get_shadow_caster_fragment_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_shadow_caster_fragment_program", VALUEFUNC(_wrap_Pass_get_shadow_caster_fragment_program), -1);
  rb_define_method(SwigClassPass.klass, "set_shadow_receiver_vertex_program", VALUEFUNC(_wrap_Pass_set_shadow_receiver_vertex_program), -1);
  rb_define_method(SwigClassPass.klass, "set_shadow_receiver_vertex_program_parameters", VALUEFUNC(_wrap_Pass_set_shadow_receiver_vertex_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "set_shadow_receiver_fragment_program", VALUEFUNC(_wrap_Pass_set_shadow_receiver_fragment_program), -1);
  rb_define_method(SwigClassPass.klass, "set_shadow_receiver_fragment_program_parameters", VALUEFUNC(_wrap_Pass_set_shadow_receiver_fragment_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_shadow_receiver_vertex_program_name", VALUEFUNC(_wrap_Pass_get_shadow_receiver_vertex_program_name), -1);
  rb_define_method(SwigClassPass.klass, "get_shadow_receiver_vertex_program_parameters", VALUEFUNC(_wrap_Pass_get_shadow_receiver_vertex_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_shadow_receiver_vertex_program", VALUEFUNC(_wrap_Pass_get_shadow_receiver_vertex_program), -1);
  rb_define_method(SwigClassPass.klass, "get_shadow_receiver_fragment_program_name", VALUEFUNC(_wrap_Pass_get_shadow_receiver_fragment_program_name), -1);
  rb_define_method(SwigClassPass.klass, "get_shadow_receiver_fragment_program_parameters", VALUEFUNC(_wrap_Pass_get_shadow_receiver_fragment_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_shadow_receiver_fragment_program", VALUEFUNC(_wrap_Pass_get_shadow_receiver_fragment_program), -1);
  rb_define_method(SwigClassPass.klass, "set_fragment_program", VALUEFUNC(_wrap_Pass_set_fragment_program), -1);
  rb_define_method(SwigClassPass.klass, "set_fragment_program_parameters", VALUEFUNC(_wrap_Pass_set_fragment_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_fragment_program_name", VALUEFUNC(_wrap_Pass_get_fragment_program_name), -1);
  rb_define_method(SwigClassPass.klass, "get_fragment_program_parameters", VALUEFUNC(_wrap_Pass_get_fragment_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_fragment_program", VALUEFUNC(_wrap_Pass_get_fragment_program), -1);
  rb_define_method(SwigClassPass.klass, "set_geometry_program", VALUEFUNC(_wrap_Pass_set_geometry_program), -1);
  rb_define_method(SwigClassPass.klass, "set_geometry_program_parameters", VALUEFUNC(_wrap_Pass_set_geometry_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_geometry_program_name", VALUEFUNC(_wrap_Pass_get_geometry_program_name), -1);
  rb_define_method(SwigClassPass.klass, "get_geometry_program_parameters", VALUEFUNC(_wrap_Pass_get_geometry_program_parameters), -1);
  rb_define_method(SwigClassPass.klass, "get_geometry_program", VALUEFUNC(_wrap_Pass_get_geometry_program), -1);
  rb_define_method(SwigClassPass.klass, "_split", VALUEFUNC(_wrap_Pass__split), -1);
  rb_define_method(SwigClassPass.klass, "_notify_index", VALUEFUNC(_wrap_Pass__notify_index), -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, "is_loaded", VALUEFUNC(_wrap_Pass_is_loaded), -1);
  rb_define_method(SwigClassPass.klass, "get_hash", VALUEFUNC(_wrap_Pass_get_hash), -1);
  rb_define_method(SwigClassPass.klass, "_dirty_hash", VALUEFUNC(_wrap_Pass__dirty_hash), -1);
  rb_define_method(SwigClassPass.klass, "_recalculate_hash", VALUEFUNC(_wrap_Pass__recalculate_hash), -1);
  rb_define_method(SwigClassPass.klass, "_notify_needs_recompile", VALUEFUNC(_wrap_Pass__notify_needs_recompile), -1);
  rb_define_method(SwigClassPass.klass, "_update_auto_params", VALUEFUNC(_wrap_Pass__update_auto_params), -1);
  rb_define_method(SwigClassPass.klass, "_get_texture_unit_with_content_type_index", VALUEFUNC(_wrap_Pass__get_texture_unit_with_content_type_index), -1);
  rb_define_method(SwigClassPass.klass, "set_texture_filtering", VALUEFUNC(_wrap_Pass_set_texture_filtering), -1);
  rb_define_method(SwigClassPass.klass, "set_texture_anisotropy", VALUEFUNC(_wrap_Pass_set_texture_anisotropy), -1);
  rb_define_method(SwigClassPass.klass, "set_normalise_normals", VALUEFUNC(_wrap_Pass_set_normalise_normals), -1);
  rb_define_method(SwigClassPass.klass, "get_normalise_normals", VALUEFUNC(_wrap_Pass_get_normalise_normals), -1);
  rb_define_singleton_method(SwigClassPass.klass, "get_dirty_hash_list", VALUEFUNC(_wrap_Pass_get_dirty_hash_list), -1);
  rb_define_singleton_method(SwigClassPass.klass, "get_pass_graveyard", VALUEFUNC(_wrap_Pass_get_pass_graveyard), -1);
  rb_define_singleton_method(SwigClassPass.klass, "clear_dirty_hash_list", VALUEFUNC(_wrap_Pass_clear_dirty_hash_list), -1);
  rb_define_singleton_method(SwigClassPass.klass, "process_pending_pass_updates", VALUEFUNC(_wrap_Pass_process_pending_pass_updates), -1);
  rb_define_method(SwigClassPass.klass, "queue_for_deletion", VALUEFUNC(_wrap_Pass_queue_for_deletion), -1);
  rb_define_method(SwigClassPass.klass, "is_ambient_only", VALUEFUNC(_wrap_Pass_is_ambient_only), -1);
  rb_define_method(SwigClassPass.klass, "set_pass_iteration_count", VALUEFUNC(_wrap_Pass_set_pass_iteration_count), -1);
  rb_define_method(SwigClassPass.klass, "get_pass_iteration_count", VALUEFUNC(_wrap_Pass_get_pass_iteration_count), -1);
  rb_define_method(SwigClassPass.klass, "apply_texture_aliases", VALUEFUNC(_wrap_Pass_apply_texture_aliases), -1);
  rb_define_method(SwigClassPass.klass, "set_light_scissoring_enabled", VALUEFUNC(_wrap_Pass_set_light_scissoring_enabled), -1);
  rb_define_method(SwigClassPass.klass, "get_light_scissoring_enabled", VALUEFUNC(_wrap_Pass_get_light_scissoring_enabled), -1);
  rb_define_method(SwigClassPass.klass, "set_light_clip_planes_enabled", VALUEFUNC(_wrap_Pass_set_light_clip_planes_enabled), -1);
  rb_define_method(SwigClassPass.klass, "get_light_clip_planes_enabled", VALUEFUNC(_wrap_Pass_get_light_clip_planes_enabled), -1);
  rb_define_method(SwigClassPass.klass, "set_illumination_stage", VALUEFUNC(_wrap_Pass_set_illumination_stage), -1);
  rb_define_method(SwigClassPass.klass, "get_illumination_stage", VALUEFUNC(_wrap_Pass_get_illumination_stage), -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, "set_hash_function", VALUEFUNC(_wrap_Pass_set_hash_function), -1);
  rb_define_singleton_method(SwigClassPass.klass, "get_hash_function", VALUEFUNC(_wrap_Pass_get_hash_function), -1);
  rb_define_singleton_method(SwigClassPass.klass, "get_builtin_hash_function", VALUEFUNC(_wrap_Pass_get_builtin_hash_function), -1);
  rb_define_method(SwigClassPass.klass, "get_user_object_bindings", VALUEFUNC(_wrap_Pass_get_user_object_bindings), -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, "get_base_value", VALUEFUNC(_wrap_PixelCountLodStrategy_get_base_value), -1);
  rb_define_method(SwigClassPixelCountLodStrategy.klass, "transform_bias", VALUEFUNC(_wrap_PixelCountLodStrategy_transform_bias), -1);
  rb_define_method(SwigClassPixelCountLodStrategy.klass, "get_index", VALUEFUNC(_wrap_PixelCountLodStrategy_get_index), -1);
  rb_define_method(SwigClassPixelCountLodStrategy.klass, "sort", VALUEFUNC(_wrap_PixelCountLodStrategy_sort), -1);
  rb_define_method(SwigClassPixelCountLodStrategy.klass, "is_sorted", VALUEFUNC(_wrap_PixelCountLodStrategy_is_sorted), -1);
  rb_define_singleton_method(SwigClassPixelCountLodStrategy.klass, "get_singleton", VALUEFUNC(_wrap_PixelCountLodStrategy_get_singleton), -1);
  rb_define_singleton_method(SwigClassPixelCountLodStrategy.klass, "get_singleton_ptr", VALUEFUNC(_wrap_PixelCountLodStrategy_get_singleton_ptr), -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, "get_cpu_identifier", VALUEFUNC(_wrap_PlatformInformation_get_cpu_identifier), -1);
  rb_define_singleton_method(SwigClassPlatformInformation.klass, "get_cpu_features", VALUEFUNC(_wrap_PlatformInformation_get_cpu_features), -1);
  rb_define_singleton_method(SwigClassPlatformInformation.klass, "has_cpu_feature", VALUEFUNC(_wrap_PlatformInformation_has_cpu_feature), -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, "get_name", VALUEFUNC(_wrap_Plugin_get_name), -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, "create_prefab", VALUEFUNC(_wrap_PrefabFactory_create_prefab), -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, "set_timer", VALUEFUNC(_wrap_Profiler_set_timer), -1);
  rb_define_method(SwigClassProfiler.klass, "get_timer", VALUEFUNC(_wrap_Profiler_get_timer), -1);
  rb_define_method(SwigClassProfiler.klass, "begin_profile", VALUEFUNC(_wrap_Profiler_begin_profile), -1);
  rb_define_method(SwigClassProfiler.klass, "end_profile", VALUEFUNC(_wrap_Profiler_end_profile), -1);
  rb_define_method(SwigClassProfiler.klass, "begin_gpuevent", VALUEFUNC(_wrap_Profiler_begin_gpuevent), -1);
  rb_define_method(SwigClassProfiler.klass, "end_gpuevent", VALUEFUNC(_wrap_Profiler_end_gpuevent), -1);
  rb_define_method(SwigClassProfiler.klass, "mark_gpuevent", VALUEFUNC(_wrap_Profiler_mark_gpuevent), -1);
  rb_define_method(SwigClassProfiler.klass, "set_enabled", VALUEFUNC(_wrap_Profiler_set_enabled), -1);
  rb_define_method(SwigClassProfiler.klass, "get_enabled", VALUEFUNC(_wrap_Profiler_get_enabled), -1);
  rb_define_method(SwigClassProfiler.klass, "enable_profile", VALUEFUNC(_wrap_Profiler_enable_profile), -1);
  rb_define_method(SwigClassProfiler.klass, "disable_profile", VALUEFUNC(_wrap_Profiler_disable_profile), -1);
  rb_define_method(SwigClassProfiler.klass, "set_profile_group_mask", VALUEFUNC(_wrap_Profiler_set_profile_group_mask), -1);
  rb_define_method(SwigClassProfiler.klass, "get_profile_group_mask", VALUEFUNC(_wrap_Profiler_get_profile_group_mask), -1);
  rb_define_method(SwigClassProfiler.klass, "watch_for_max", VALUEFUNC(_wrap_Profiler_watch_for_max), -1);
  rb_define_method(SwigClassProfiler.klass, "watch_for_min", VALUEFUNC(_wrap_Profiler_watch_for_min), -1);
  rb_define_method(SwigClassProfiler.klass, "watch_for_limit", VALUEFUNC(_wrap_Profiler_watch_for_limit), -1);
  rb_define_method(SwigClassProfiler.klass, "log_results", VALUEFUNC(_wrap_Profiler_log_results), -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, "set_display_mode", VALUEFUNC(_wrap_Profiler_set_display_mode), -1);
  rb_define_method(SwigClassProfiler.klass, "get_display_mode", VALUEFUNC(_wrap_Profiler_get_display_mode), -1);
  rb_define_method(SwigClassProfiler.klass, "set_update_display_frequency", VALUEFUNC(_wrap_Profiler_set_update_display_frequency), -1);
  rb_define_method(SwigClassProfiler.klass, "get_update_display_frequency", VALUEFUNC(_wrap_Profiler_get_update_display_frequency), -1);
  rb_define_method(SwigClassProfiler.klass, "set_overlay_dimensions", VALUEFUNC(_wrap_Profiler_set_overlay_dimensions), -1);
  rb_define_method(SwigClassProfiler.klass, "set_overlay_position", VALUEFUNC(_wrap_Profiler_set_overlay_position), -1);
  rb_define_method(SwigClassProfiler.klass, "get_overlay_width", VALUEFUNC(_wrap_Profiler_get_overlay_width), -1);
  rb_define_method(SwigClassProfiler.klass, "get_overlay_height", VALUEFUNC(_wrap_Profiler_get_overlay_height), -1);
  rb_define_method(SwigClassProfiler.klass, "get_overlay_left", VALUEFUNC(_wrap_Profiler_get_overlay_left), -1);
  rb_define_method(SwigClassProfiler.klass, "get_overlay_top", VALUEFUNC(_wrap_Profiler_get_overlay_top), -1);
  rb_define_singleton_method(SwigClassProfiler.klass, "get_singleton", VALUEFUNC(_wrap_Profiler_get_singleton), -1);
  rb_define_singleton_method(SwigClassProfiler.klass, "get_singleton_ptr", VALUEFUNC(_wrap_Profiler_get_singleton_ptr), -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, "notify_render_single_object", VALUEFUNC(_wrap_RenderObjectListener_notify_render_single_object), -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, "is_supported", VALUEFUNC(_wrap_Technique_is_supported), -1);
  rb_define_method(SwigClassTechnique.klass, "_compile", VALUEFUNC(_wrap_Technique__compile), -1);
  rb_define_method(SwigClassTechnique.klass, "check_gpurules", VALUEFUNC(_wrap_Technique_check_gpurules), -1);
  rb_define_method(SwigClassTechnique.klass, "check_hardware_support", VALUEFUNC(_wrap_Technique_check_hardware_support), -1);
  rb_define_method(SwigClassTechnique.klass, "_compile_illumination_passes", VALUEFUNC(_wrap_Technique__compile_illumination_passes), -1);
  rb_define_method(SwigClassTechnique.klass, "create_pass", VALUEFUNC(_wrap_Technique_create_pass), -1);
  rb_define_method(SwigClassTechnique.klass, "get_pass", VALUEFUNC(_wrap_Technique_get_pass), -1);
  rb_define_method(SwigClassTechnique.klass, "get_num_passes", VALUEFUNC(_wrap_Technique_get_num_passes), -1);
  rb_define_method(SwigClassTechnique.klass, "remove_pass", VALUEFUNC(_wrap_Technique_remove_pass), -1);
  rb_define_method(SwigClassTechnique.klass, "remove_all_passes", VALUEFUNC(_wrap_Technique_remove_all_passes), -1);
  rb_define_method(SwigClassTechnique.klass, "move_pass", VALUEFUNC(_wrap_Technique_move_pass), -1);
  rb_define_method(SwigClassTechnique.klass, "get_pass_iterator", VALUEFUNC(_wrap_Technique_get_pass_iterator), -1);
  rb_define_method(SwigClassTechnique.klass, "get_illumination_pass_iterator", VALUEFUNC(_wrap_Technique_get_illumination_pass_iterator), -1);
  rb_define_method(SwigClassTechnique.klass, "get_parent", VALUEFUNC(_wrap_Technique_get_parent), -1);
  rb_define_method(SwigClassTechnique.klass, "get_resource_group", VALUEFUNC(_wrap_Technique_get_resource_group), -1);
  rb_define_method(SwigClassTechnique.klass, "is_transparent", VALUEFUNC(_wrap_Technique_is_transparent), -1);
  rb_define_method(SwigClassTechnique.klass, "is_transparent_sorting_enabled", VALUEFUNC(_wrap_Technique_is_transparent_sorting_enabled), -1);
  rb_define_method(SwigClassTechnique.klass, "is_transparent_sorting_forced", VALUEFUNC(_wrap_Technique_is_transparent_sorting_forced), -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, "is_loaded", VALUEFUNC(_wrap_Technique_is_loaded), -1);
  rb_define_method(SwigClassTechnique.klass, "_notify_needs_recompile", VALUEFUNC(_wrap_Technique__notify_needs_recompile), -1);
  rb_define_method(SwigClassTechnique.klass, "get_shadow_caster_material", VALUEFUNC(_wrap_Technique_get_shadow_caster_material), -1);
  rb_define_method(SwigClassTechnique.klass, "set_shadow_caster_material", VALUEFUNC(_wrap_Technique_set_shadow_caster_material), -1);
  rb_define_method(SwigClassTechnique.klass, "get_shadow_receiver_material", VALUEFUNC(_wrap_Technique_get_shadow_receiver_material), -1);
  rb_define_method(SwigClassTechnique.klass, "set_shadow_receiver_material", VALUEFUNC(_wrap_Technique_set_shadow_receiver_material), -1);
  rb_define_method(SwigClassTechnique.klass, "set_point_size", VALUEFUNC(_wrap_Technique_set_point_size), -1);
  rb_define_method(SwigClassTechnique.klass, "set_ambient", VALUEFUNC(_wrap_Technique_set_ambient), -1);
  rb_define_method(SwigClassTechnique.klass, "set_diffuse", VALUEFUNC(_wrap_Technique_set_diffuse), -1);
  rb_define_method(SwigClassTechnique.klass, "set_specular", VALUEFUNC(_wrap_Technique_set_specular), -1);
  rb_define_method(SwigClassTechnique.klass, "set_shininess", VALUEFUNC(_wrap_Technique_set_shininess), -1);
  rb_define_method(SwigClassTechnique.klass, "set_self_illumination", VALUEFUNC(_wrap_Technique_set_self_illumination), -1);
  rb_define_method(SwigClassTechnique.klass, "set_depth_check_enabled", VALUEFUNC(_wrap_Technique_set_depth_check_enabled), -1);
  rb_define_method(SwigClassTechnique.klass, "set_depth_write_enabled", VALUEFUNC(_wrap_Technique_set_depth_write_enabled), -1);
  rb_define_method(SwigClassTechnique.klass, "set_depth_function", VALUEFUNC(_wrap_Technique_set_depth_function), -1);
  rb_define_method(SwigClassTechnique.klass, "set_colour_write_enabled", VALUEFUNC(_wrap_Technique_set_colour_write_enabled), -1);
  rb_define_method(SwigClassTechnique.klass, "set_culling_mode", VALUEFUNC(_wrap_Technique_set_culling_mode), -1);
  rb_define_method(SwigClassTechnique.klass, "set_manual_culling_mode", VALUEFUNC(_wrap_Technique_set_manual_culling_mode), -1);
  rb_define_method(SwigClassTechnique.klass, "set_lighting_enabled", VALUEFUNC(_wrap_Technique_set_lighting_enabled), -1);
  rb_define_method(SwigClassTechnique.klass, "set_shading_mode", VALUEFUNC(_wrap_Technique_set_shading_mode), -1);
  rb_define_method(SwigClassTechnique.klass, "set_fog", VALUEFUNC(_wrap_Technique_set_fog), -1);
  rb_define_method(SwigClassTechnique.klass, "set_depth_bias", VALUEFUNC(_wrap_Technique_set_depth_bias), -1);
  rb_define_method(SwigClassTechnique.klass, "set_texture_filtering", VALUEFUNC(_wrap_Technique_set_texture_filtering), -1);
  rb_define_method(SwigClassTechnique.klass, "set_texture_anisotropy", VALUEFUNC(_wrap_Technique_set_texture_anisotropy), -1);
  rb_define_method(SwigClassTechnique.klass, "set_scene_blending", VALUEFUNC(_wrap_Technique_set_scene_blending), -1);
  rb_define_method(SwigClassTechnique.klass, "set_separate_scene_blending", VALUEFUNC(_wrap_Technique_set_separate_scene_blending), -1);
  rb_define_method(SwigClassTechnique.klass, "set_lod_index", VALUEFUNC(_wrap_Technique_set_lod_index), -1);
  rb_define_method(SwigClassTechnique.klass, "get_lod_index", VALUEFUNC(_wrap_Technique_get_lod_index), -1);
  rb_define_method(SwigClassTechnique.klass, "set_scheme_name", VALUEFUNC(_wrap_Technique_set_scheme_name), -1);
  rb_define_method(SwigClassTechnique.klass, "get_scheme_name", VALUEFUNC(_wrap_Technique_get_scheme_name), -1);
  rb_define_method(SwigClassTechnique.klass, "_get_scheme_index", VALUEFUNC(_wrap_Technique__get_scheme_index), -1);
  rb_define_method(SwigClassTechnique.klass, "is_depth_write_enabled", VALUEFUNC(_wrap_Technique_is_depth_write_enabled), -1);
  rb_define_method(SwigClassTechnique.klass, "is_depth_check_enabled", VALUEFUNC(_wrap_Technique_is_depth_check_enabled), -1);
  rb_define_method(SwigClassTechnique.klass, "has_colour_write_disabled", VALUEFUNC(_wrap_Technique_has_colour_write_disabled), -1);
  rb_define_method(SwigClassTechnique.klass, "set_name", VALUEFUNC(_wrap_Technique_set_name), -1);
  rb_define_method(SwigClassTechnique.klass, "get_name", VALUEFUNC(_wrap_Technique_get_name), -1);
  rb_define_method(SwigClassTechnique.klass, "apply_texture_aliases", VALUEFUNC(_wrap_Technique_apply_texture_aliases), -1);
  rb_define_method(SwigClassTechnique.klass, "add_gpuvendor_rule", VALUEFUNC(_wrap_Technique_add_gpuvendor_rule), -1);
  rb_define_method(SwigClassTechnique.klass, "remove_gpuvendor_rule", VALUEFUNC(_wrap_Technique_remove_gpuvendor_rule), -1);
  rb_define_method(SwigClassTechnique.klass, "get_gpuvendor_rule_iterator", VALUEFUNC(_wrap_Technique_get_gpuvendor_rule_iterator), -1);
  rb_define_method(SwigClassTechnique.klass, "add_gpudevice_name_rule", VALUEFUNC(_wrap_Technique_add_gpudevice_name_rule), -1);
  rb_define_method(SwigClassTechnique.klass, "remove_gpudevice_name_rule", VALUEFUNC(_wrap_Technique_remove_gpudevice_name_rule), -1);
  rb_define_method(SwigClassTechnique.klass, "get_gpudevice_name_rule_iterator", VALUEFUNC(_wrap_Technique_get_gpudevice_name_rule_iterator), -1);
  rb_define_method(SwigClassTechnique.klass, "get_user_object_bindings", VALUEFUNC(_wrap_Technique_get_user_object_bindings), -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, "remove_pass_group", VALUEFUNC(_wrap_QueuedRenderableCollection_remove_pass_group), -1);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "reset_organisation_modes", VALUEFUNC(_wrap_QueuedRenderableCollection_reset_organisation_modes), -1);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "add_organisation_mode", VALUEFUNC(_wrap_QueuedRenderableCollection_add_organisation_mode), -1);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "add_renderable", VALUEFUNC(_wrap_QueuedRenderableCollection_add_renderable), -1);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "sort", VALUEFUNC(_wrap_QueuedRenderableCollection_sort), -1);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "accept_visitor", VALUEFUNC(_wrap_QueuedRenderableCollection_accept_visitor), -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, "get_solids_basic", VALUEFUNC(_wrap_RenderPriorityGroup_get_solids_basic), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "get_solids_diffuse_specular", VALUEFUNC(_wrap_RenderPriorityGroup_get_solids_diffuse_specular), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "get_solids_decal", VALUEFUNC(_wrap_RenderPriorityGroup_get_solids_decal), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "get_solids_no_shadow_receive", VALUEFUNC(_wrap_RenderPriorityGroup_get_solids_no_shadow_receive), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "get_transparents_unsorted", VALUEFUNC(_wrap_RenderPriorityGroup_get_transparents_unsorted), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "get_transparents", VALUEFUNC(_wrap_RenderPriorityGroup_get_transparents), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "reset_organisation_modes", VALUEFUNC(_wrap_RenderPriorityGroup_reset_organisation_modes), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "add_organisation_mode", VALUEFUNC(_wrap_RenderPriorityGroup_add_organisation_mode), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "default_organisation_mode", VALUEFUNC(_wrap_RenderPriorityGroup_default_organisation_mode), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "add_renderable", VALUEFUNC(_wrap_RenderPriorityGroup_add_renderable), -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, "set_split_passes_by_lighting_type", VALUEFUNC(_wrap_RenderPriorityGroup_set_split_passes_by_lighting_type), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "set_split_no_shadow_passes", VALUEFUNC(_wrap_RenderPriorityGroup_set_split_no_shadow_passes), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "set_shadow_casters_cannot_be_receivers", VALUEFUNC(_wrap_RenderPriorityGroup_set_shadow_casters_cannot_be_receivers), -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, "get_iterator", VALUEFUNC(_wrap_RenderQueueGroup_get_iterator), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "add_renderable", VALUEFUNC(_wrap_RenderQueueGroup_add_renderable), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "clear", VALUEFUNC(_wrap_RenderQueueGroup_clear), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "set_shadows_enabled", VALUEFUNC(_wrap_RenderQueueGroup_set_shadows_enabled), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "get_shadows_enabled", VALUEFUNC(_wrap_RenderQueueGroup_get_shadows_enabled), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "set_split_passes_by_lighting_type", VALUEFUNC(_wrap_RenderQueueGroup_set_split_passes_by_lighting_type), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "set_split_no_shadow_passes", VALUEFUNC(_wrap_RenderQueueGroup_set_split_no_shadow_passes), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "set_shadow_casters_cannot_be_receivers", VALUEFUNC(_wrap_RenderQueueGroup_set_shadow_casters_cannot_be_receivers), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "reset_organisation_modes", VALUEFUNC(_wrap_RenderQueueGroup_reset_organisation_modes), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "add_organisation_mode", VALUEFUNC(_wrap_RenderQueueGroup_add_organisation_mode), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "default_organisation_mode", VALUEFUNC(_wrap_RenderQueueGroup_default_organisation_mode), -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, "get_render_queue_group_id", VALUEFUNC(_wrap_RenderQueueInvocation_get_render_queue_group_id), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "get_invocation_name", VALUEFUNC(_wrap_RenderQueueInvocation_get_invocation_name), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "set_solids_organisation", VALUEFUNC(_wrap_RenderQueueInvocation_set_solids_organisation), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "get_solids_organisation", VALUEFUNC(_wrap_RenderQueueInvocation_get_solids_organisation), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "set_suppress_shadows", VALUEFUNC(_wrap_RenderQueueInvocation_set_suppress_shadows), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "get_suppress_shadows", VALUEFUNC(_wrap_RenderQueueInvocation_get_suppress_shadows), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "set_suppress_render_state_changes", VALUEFUNC(_wrap_RenderQueueInvocation_set_suppress_render_state_changes), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "get_suppress_render_state_changes", VALUEFUNC(_wrap_RenderQueueInvocation_get_suppress_render_state_changes), -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, "get_name", VALUEFUNC(_wrap_RenderQueueInvocationSequence_get_name), -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, "parse_capabilities_from_archive", VALUEFUNC(_wrap_RenderSystemCapabilitiesManager_parse_capabilities_from_archive), -1);
  rb_define_method(SwigClassRenderSystemCapabilitiesManager.klass, "load_parsed_capabilities", VALUEFUNC(_wrap_RenderSystemCapabilitiesManager_load_parsed_capabilities), -1);
  rb_define_method(SwigClassRenderSystemCapabilitiesManager.klass, "get_capabilities", VALUEFUNC(_wrap_RenderSystemCapabilitiesManager_get_capabilities), -1);
  rb_define_method(SwigClassRenderSystemCapabilitiesManager.klass, "_add_render_system_capabilities", VALUEFUNC(_wrap_RenderSystemCapabilitiesManager__add_render_system_capabilities), -1);
  rb_define_singleton_method(SwigClassRenderSystemCapabilitiesManager.klass, "get_singleton", VALUEFUNC(_wrap_RenderSystemCapabilitiesManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassRenderSystemCapabilitiesManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_RenderSystemCapabilitiesManager_get_singleton_ptr), -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, "write_script", VALUEFUNC(_wrap_RenderSystemCapabilitiesSerializer_write_script), -1);
  rb_define_method(SwigClassRenderSystemCapabilitiesSerializer.klass, "write_string", VALUEFUNC(_wrap_RenderSystemCapabilitiesSerializer_write_string), -1);
  rb_define_method(SwigClassRenderSystemCapabilitiesSerializer.klass, "parse_script", VALUEFUNC(_wrap_RenderSystemCapabilitiesSerializer_parse_script), -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, "set_fullscreen", VALUEFUNC(_wrap_RenderWindow_set_fullscreen), -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, "window_moved_or_resized", VALUEFUNC(_wrap_RenderWindow_window_moved_or_resized), -1);
  rb_define_method(SwigClassRenderWindow.klass, "reposition", VALUEFUNC(_wrap_RenderWindow_reposition), -1);
  rb_define_method(SwigClassRenderWindow.klass, "is_visible", VALUEFUNC(_wrap_RenderWindow_is_visible), -1);
  rb_define_method(SwigClassRenderWindow.klass, "set_visible", VALUEFUNC(_wrap_RenderWindow_set_visible), -1);
  rb_define_method(SwigClassRenderWindow.klass, "is_hidden", VALUEFUNC(_wrap_RenderWindow_is_hidden), -1);
  rb_define_method(SwigClassRenderWindow.klass, "set_hidden", VALUEFUNC(_wrap_RenderWindow_set_hidden), -1);
  rb_define_method(SwigClassRenderWindow.klass, "set_vsync_enabled", VALUEFUNC(_wrap_RenderWindow_set_vsync_enabled), -1);
  rb_define_method(SwigClassRenderWindow.klass, "is_vsync_enabled", VALUEFUNC(_wrap_RenderWindow_is_vsync_enabled), -1);
  rb_define_method(SwigClassRenderWindow.klass, "set_vsync_interval", VALUEFUNC(_wrap_RenderWindow_set_vsync_interval), -1);
  rb_define_method(SwigClassRenderWindow.klass, "get_vsync_interval", VALUEFUNC(_wrap_RenderWindow_get_vsync_interval), -1);
  rb_define_method(SwigClassRenderWindow.klass, "is_active", VALUEFUNC(_wrap_RenderWindow_is_active), -1);
  rb_define_method(SwigClassRenderWindow.klass, "is_closed", VALUEFUNC(_wrap_RenderWindow_is_closed), -1);
  rb_define_method(SwigClassRenderWindow.klass, "is_primary", VALUEFUNC(_wrap_RenderWindow_is_primary), -1);
  rb_define_method(SwigClassRenderWindow.klass, "is_full_screen", VALUEFUNC(_wrap_RenderWindow_is_full_screen), -1);
  rb_define_method(SwigClassRenderWindow.klass, "get_metrics", VALUEFUNC(_wrap_RenderWindow_get_metrics), -1);
  rb_define_method(SwigClassRenderWindow.klass, "suggest_pixel_format", VALUEFUNC(_wrap_RenderWindow_suggest_pixel_format), -1);
  rb_define_method(SwigClassRenderWindow.klass, "is_deactivated_on_focus_change", VALUEFUNC(_wrap_RenderWindow_is_deactivated_on_focus_change), -1);
  rb_define_method(SwigClassRenderWindow.klass, "set_deactivate_on_focus_change", VALUEFUNC(_wrap_RenderWindow_set_deactivate_on_focus_change), -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, "add_request_handler", VALUEFUNC(_wrap_WorkQueue_add_request_handler), -1);
  rb_define_method(SwigClassWorkQueue.klass, "remove_request_handler", VALUEFUNC(_wrap_WorkQueue_remove_request_handler), -1);
  rb_define_method(SwigClassWorkQueue.klass, "add_response_handler", VALUEFUNC(_wrap_WorkQueue_add_response_handler), -1);
  rb_define_method(SwigClassWorkQueue.klass, "remove_response_handler", VALUEFUNC(_wrap_WorkQueue_remove_response_handler), -1);
  rb_define_method(SwigClassWorkQueue.klass, "add_request", VALUEFUNC(_wrap_WorkQueue_add_request), -1);
  rb_define_method(SwigClassWorkQueue.klass, "abort_request", VALUEFUNC(_wrap_WorkQueue_abort_request), -1);
  rb_define_method(SwigClassWorkQueue.klass, "abort_requests_by_channel", VALUEFUNC(_wrap_WorkQueue_abort_requests_by_channel), -1);
  rb_define_method(SwigClassWorkQueue.klass, "abort_all_requests", VALUEFUNC(_wrap_WorkQueue_abort_all_requests), -1);
  rb_define_method(SwigClassWorkQueue.klass, "set_paused", VALUEFUNC(_wrap_WorkQueue_set_paused), -1);
  rb_define_method(SwigClassWorkQueue.klass, "is_paused", VALUEFUNC(_wrap_WorkQueue_is_paused), -1);
  rb_define_method(SwigClassWorkQueue.klass, "set_requests_accepted", VALUEFUNC(_wrap_WorkQueue_set_requests_accepted), -1);
  rb_define_method(SwigClassWorkQueue.klass, "get_requests_accepted", VALUEFUNC(_wrap_WorkQueue_get_requests_accepted), -1);
  rb_define_method(SwigClassWorkQueue.klass, "process_responses", VALUEFUNC(_wrap_WorkQueue_process_responses), -1);
  rb_define_method(SwigClassWorkQueue.klass, "get_response_processing_time_limit", VALUEFUNC(_wrap_WorkQueue_get_response_processing_time_limit), -1);
  rb_define_method(SwigClassWorkQueue.klass, "set_response_processing_time_limit", VALUEFUNC(_wrap_WorkQueue_set_response_processing_time_limit), -1);
  rb_define_method(SwigClassWorkQueue.klass, "shutdown", VALUEFUNC(_wrap_WorkQueue_shutdown), -1);
  rb_define_method(SwigClassWorkQueue.klass, "get_channel", VALUEFUNC(_wrap_WorkQueue_get_channel), -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, "get_name", VALUEFUNC(_wrap_DefaultWorkQueueBase_get_name), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "get_worker_thread_count", VALUEFUNC(_wrap_DefaultWorkQueueBase_get_worker_thread_count), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "set_worker_thread_count", VALUEFUNC(_wrap_DefaultWorkQueueBase_set_worker_thread_count), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "get_workers_can_access_render_system", VALUEFUNC(_wrap_DefaultWorkQueueBase_get_workers_can_access_render_system), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "set_workers_can_access_render_system", VALUEFUNC(_wrap_DefaultWorkQueueBase_set_workers_can_access_render_system), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "_process_next_request", VALUEFUNC(_wrap_DefaultWorkQueueBase__process_next_request), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "_thread_main", VALUEFUNC(_wrap_DefaultWorkQueueBase__thread_main), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "is_shutting_down", VALUEFUNC(_wrap_DefaultWorkQueueBase_is_shutting_down), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "add_request_handler", VALUEFUNC(_wrap_DefaultWorkQueueBase_add_request_handler), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "remove_request_handler", VALUEFUNC(_wrap_DefaultWorkQueueBase_remove_request_handler), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "add_response_handler", VALUEFUNC(_wrap_DefaultWorkQueueBase_add_response_handler), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "remove_response_handler", VALUEFUNC(_wrap_DefaultWorkQueueBase_remove_response_handler), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "add_request", VALUEFUNC(_wrap_DefaultWorkQueueBase_add_request), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "abort_request", VALUEFUNC(_wrap_DefaultWorkQueueBase_abort_request), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "abort_requests_by_channel", VALUEFUNC(_wrap_DefaultWorkQueueBase_abort_requests_by_channel), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "abort_all_requests", VALUEFUNC(_wrap_DefaultWorkQueueBase_abort_all_requests), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "set_paused", VALUEFUNC(_wrap_DefaultWorkQueueBase_set_paused), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "is_paused", VALUEFUNC(_wrap_DefaultWorkQueueBase_is_paused), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "set_requests_accepted", VALUEFUNC(_wrap_DefaultWorkQueueBase_set_requests_accepted), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "get_requests_accepted", VALUEFUNC(_wrap_DefaultWorkQueueBase_get_requests_accepted), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "process_responses", VALUEFUNC(_wrap_DefaultWorkQueueBase_process_responses), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "get_response_processing_time_limit", VALUEFUNC(_wrap_DefaultWorkQueueBase_get_response_processing_time_limit), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "set_response_processing_time_limit", VALUEFUNC(_wrap_DefaultWorkQueueBase_set_response_processing_time_limit), -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, "initialise_resource_group", VALUEFUNC(_wrap_ResourceBackgroundQueue_initialise_resource_group), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "initialise_all_resource_groups", VALUEFUNC(_wrap_ResourceBackgroundQueue_initialise_all_resource_groups), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "prepare_resource_group", VALUEFUNC(_wrap_ResourceBackgroundQueue_prepare_resource_group), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "load_resource_group", VALUEFUNC(_wrap_ResourceBackgroundQueue_load_resource_group), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "unload", VALUEFUNC(_wrap_ResourceBackgroundQueue_unload), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "unload_resource_group", VALUEFUNC(_wrap_ResourceBackgroundQueue_unload_resource_group), -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, "is_process_complete", VALUEFUNC(_wrap_ResourceBackgroundQueue_is_process_complete), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "abort_request", VALUEFUNC(_wrap_ResourceBackgroundQueue_abort_request), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "can_handle_request", VALUEFUNC(_wrap_ResourceBackgroundQueue_can_handle_request), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "handle_request", VALUEFUNC(_wrap_ResourceBackgroundQueue_handle_request), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "can_handle_response", VALUEFUNC(_wrap_ResourceBackgroundQueue_can_handle_response), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "handle_response", VALUEFUNC(_wrap_ResourceBackgroundQueue_handle_response), -1);
  rb_define_singleton_method(SwigClassResourceBackgroundQueue.klass, "get_singleton", VALUEFUNC(_wrap_ResourceBackgroundQueue_get_singleton), -1);
  rb_define_singleton_method(SwigClassResourceBackgroundQueue.klass, "get_singleton_ptr", VALUEFUNC(_wrap_ResourceBackgroundQueue_get_singleton_ptr), -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, "add_node", VALUEFUNC(_wrap_RibbonTrail_add_node), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "remove_node", VALUEFUNC(_wrap_RibbonTrail_remove_node), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "get_node_iterator", VALUEFUNC(_wrap_RibbonTrail_get_node_iterator), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "get_chain_index_for_node", VALUEFUNC(_wrap_RibbonTrail_get_chain_index_for_node), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "set_trail_length", VALUEFUNC(_wrap_RibbonTrail_set_trail_length), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "get_trail_length", VALUEFUNC(_wrap_RibbonTrail_get_trail_length), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "set_max_chain_elements", VALUEFUNC(_wrap_RibbonTrail_set_max_chain_elements), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "set_number_of_chains", VALUEFUNC(_wrap_RibbonTrail_set_number_of_chains), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "clear_chain", VALUEFUNC(_wrap_RibbonTrail_clear_chain), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "set_initial_colour", VALUEFUNC(_wrap_RibbonTrail_set_initial_colour), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "get_initial_colour", VALUEFUNC(_wrap_RibbonTrail_get_initial_colour), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "set_initial_width", VALUEFUNC(_wrap_RibbonTrail_set_initial_width), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "get_initial_width", VALUEFUNC(_wrap_RibbonTrail_get_initial_width), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "set_width_change", VALUEFUNC(_wrap_RibbonTrail_set_width_change), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "get_width_change", VALUEFUNC(_wrap_RibbonTrail_get_width_change), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "set_colour_change", VALUEFUNC(_wrap_RibbonTrail_set_colour_change), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "get_colour_change", VALUEFUNC(_wrap_RibbonTrail_get_colour_change), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "node_updated", VALUEFUNC(_wrap_RibbonTrail_node_updated), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "node_destroyed", VALUEFUNC(_wrap_RibbonTrail_node_destroyed), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "_time_update", VALUEFUNC(_wrap_RibbonTrail__time_update), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "get_movable_type", VALUEFUNC(_wrap_RibbonTrail_get_movable_type), -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, "get_type", VALUEFUNC(_wrap_RibbonTrailFactory_get_type), -1);
  rb_define_method(SwigClassRibbonTrailFactory.klass, "destroy_instance", VALUEFUNC(_wrap_RibbonTrailFactory_destroy_instance), -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, "attach_object", VALUEFUNC(_wrap_SceneNode_attach_object), -1);
  rb_define_method(SwigClassSceneNode.klass, "num_attached_objects", VALUEFUNC(_wrap_SceneNode_num_attached_objects), -1);
  rb_define_method(SwigClassSceneNode.klass, "get_attached_object", VALUEFUNC(_wrap_SceneNode_get_attached_object), -1);
  rb_define_method(SwigClassSceneNode.klass, "detach_object", VALUEFUNC(_wrap_SceneNode_detach_object), -1);
  rb_define_method(SwigClassSceneNode.klass, "detach_all_objects", VALUEFUNC(_wrap_SceneNode_detach_all_objects), -1);
  rb_define_method(SwigClassSceneNode.klass, "is_in_scene_graph", VALUEFUNC(_wrap_SceneNode_is_in_scene_graph), -1);
  rb_define_method(SwigClassSceneNode.klass, "_notify_root_node", VALUEFUNC(_wrap_SceneNode__notify_root_node), -1);
  rb_define_method(SwigClassSceneNode.klass, "_update", VALUEFUNC(_wrap_SceneNode__update), -1);
  rb_define_method(SwigClassSceneNode.klass, "_update_bounds", VALUEFUNC(_wrap_SceneNode__update_bounds), -1);
  rb_define_method(SwigClassSceneNode.klass, "_find_visible_objects", VALUEFUNC(_wrap_SceneNode__find_visible_objects), -1);
  rb_define_method(SwigClassSceneNode.klass, "_get_world_aabb", VALUEFUNC(_wrap_SceneNode__get_world_aabb), -1);
  rb_define_method(SwigClassSceneNode.klass, "get_creator", VALUEFUNC(_wrap_SceneNode_get_creator), -1);
  rb_define_method(SwigClassSceneNode.klass, "remove_and_destroy_child", VALUEFUNC(_wrap_SceneNode_remove_and_destroy_child), -1);
  rb_define_method(SwigClassSceneNode.klass, "remove_and_destroy_all_children", VALUEFUNC(_wrap_SceneNode_remove_and_destroy_all_children), -1);
  rb_define_method(SwigClassSceneNode.klass, "show_bounding_box", VALUEFUNC(_wrap_SceneNode_show_bounding_box), -1);
  rb_define_method(SwigClassSceneNode.klass, "hide_bounding_box", VALUEFUNC(_wrap_SceneNode_hide_bounding_box), -1);
  rb_define_method(SwigClassSceneNode.klass, "_add_bounding_box_to_queue", VALUEFUNC(_wrap_SceneNode__add_bounding_box_to_queue), -1);
  rb_define_method(SwigClassSceneNode.klass, "get_show_bounding_box", VALUEFUNC(_wrap_SceneNode_get_show_bounding_box), -1);
  rb_define_method(SwigClassSceneNode.klass, "create_child_scene_node", VALUEFUNC(_wrap_SceneNode_create_child_scene_node), -1);
  rb_define_method(SwigClassSceneNode.klass, "find_lights", VALUEFUNC(_wrap_SceneNode_find_lights), -1);
  rb_define_method(SwigClassSceneNode.klass, "set_fixed_yaw_axis", VALUEFUNC(_wrap_SceneNode_set_fixed_yaw_axis), -1);
  rb_define_method(SwigClassSceneNode.klass, "yaw", VALUEFUNC(_wrap_SceneNode_yaw), -1);
  rb_define_method(SwigClassSceneNode.klass, "set_direction", VALUEFUNC(_wrap_SceneNode_set_direction), -1);
  rb_define_method(SwigClassSceneNode.klass, "look_at", VALUEFUNC(_wrap_SceneNode_look_at), -1);
  rb_define_method(SwigClassSceneNode.klass, "set_auto_tracking", VALUEFUNC(_wrap_SceneNode_set_auto_tracking), -1);
  rb_define_method(SwigClassSceneNode.klass, "get_auto_track_target", VALUEFUNC(_wrap_SceneNode_get_auto_track_target), -1);
  rb_define_method(SwigClassSceneNode.klass, "get_auto_track_offset", VALUEFUNC(_wrap_SceneNode_get_auto_track_offset), -1);
  rb_define_method(SwigClassSceneNode.klass, "get_auto_track_local_direction", VALUEFUNC(_wrap_SceneNode_get_auto_track_local_direction), -1);
  rb_define_method(SwigClassSceneNode.klass, "_auto_track", VALUEFUNC(_wrap_SceneNode__auto_track), -1);
  rb_define_method(SwigClassSceneNode.klass, "get_parent_scene_node", VALUEFUNC(_wrap_SceneNode_get_parent_scene_node), -1);
  rb_define_method(SwigClassSceneNode.klass, "set_visible", VALUEFUNC(_wrap_SceneNode_set_visible), -1);
  rb_define_method(SwigClassSceneNode.klass, "flip_visibility", VALUEFUNC(_wrap_SceneNode_flip_visibility), -1);
  rb_define_method(SwigClassSceneNode.klass, "set_debug_display_enabled", VALUEFUNC(_wrap_SceneNode_set_debug_display_enabled), -1);
  rb_define_method(SwigClassSceneNode.klass, "get_debug_renderable", VALUEFUNC(_wrap_SceneNode_get_debug_renderable), -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, "set_query_mask", VALUEFUNC(_wrap_SceneQuery_set_query_mask), -1);
  rb_define_method(SwigClassSceneQuery.klass, "get_query_mask", VALUEFUNC(_wrap_SceneQuery_get_query_mask), -1);
  rb_define_method(SwigClassSceneQuery.klass, "set_query_type_mask", VALUEFUNC(_wrap_SceneQuery_set_query_type_mask), -1);
  rb_define_method(SwigClassSceneQuery.klass, "get_query_type_mask", VALUEFUNC(_wrap_SceneQuery_get_query_type_mask), -1);
  rb_define_method(SwigClassSceneQuery.klass, "set_world_fragment_type", VALUEFUNC(_wrap_SceneQuery_set_world_fragment_type), -1);
  rb_define_method(SwigClassSceneQuery.klass, "get_world_fragment_type", VALUEFUNC(_wrap_SceneQuery_get_world_fragment_type), -1);
  rb_define_method(SwigClassSceneQuery.klass, "get_supported_world_fragment_types", VALUEFUNC(_wrap_SceneQuery_get_supported_world_fragment_types), -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, "query_result", VALUEFUNC(_wrap_SceneQueryListener_query_result), -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, "get_last_results", VALUEFUNC(_wrap_RegionSceneQuery_get_last_results), -1);
  rb_define_method(SwigClassRegionSceneQuery.klass, "clear_results", VALUEFUNC(_wrap_RegionSceneQuery_clear_results), -1);
  rb_define_method(SwigClassRegionSceneQuery.klass, "query_result", VALUEFUNC(_wrap_RegionSceneQuery_query_result), -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, "set_box", VALUEFUNC(_wrap_AxisAlignedBoxSceneQuery_set_box), -1);
  rb_define_method(SwigClassAxisAlignedBoxSceneQuery.klass, "get_box", VALUEFUNC(_wrap_AxisAlignedBoxSceneQuery_get_box), -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, "set_sphere", VALUEFUNC(_wrap_SphereSceneQuery_set_sphere), -1);
  rb_define_method(SwigClassSphereSceneQuery.klass, "get_sphere", VALUEFUNC(_wrap_SphereSceneQuery_get_sphere), -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, "set_volumes", VALUEFUNC(_wrap_PlaneBoundedVolumeListSceneQuery_set_volumes), -1);
  rb_define_method(SwigClassPlaneBoundedVolumeListSceneQuery.klass, "get_volumes", VALUEFUNC(_wrap_PlaneBoundedVolumeListSceneQuery_get_volumes), -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, "query_result", VALUEFUNC(_wrap_RaySceneQueryListener_query_result), -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, "set_ray", VALUEFUNC(_wrap_RaySceneQuery_set_ray), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "get_ray", VALUEFUNC(_wrap_RaySceneQuery_get_ray), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "set_sort_by_distance", VALUEFUNC(_wrap_RaySceneQuery_set_sort_by_distance), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "get_sort_by_distance", VALUEFUNC(_wrap_RaySceneQuery_get_sort_by_distance), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "get_max_results", VALUEFUNC(_wrap_RaySceneQuery_get_max_results), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "execute", VALUEFUNC(_wrap_RaySceneQuery_execute), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "get_last_results", VALUEFUNC(_wrap_RaySceneQuery_get_last_results), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "clear_results", VALUEFUNC(_wrap_RaySceneQuery_clear_results), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "query_result", VALUEFUNC(_wrap_RaySceneQuery_query_result), -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, "query_result", VALUEFUNC(_wrap_IntersectionSceneQueryListener_query_result), -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, "get_last_results", VALUEFUNC(_wrap_IntersectionSceneQuery_get_last_results), -1);
  rb_define_method(SwigClassIntersectionSceneQuery.klass, "clear_results", VALUEFUNC(_wrap_IntersectionSceneQuery_clear_results), -1);
  rb_define_method(SwigClassIntersectionSceneQuery.klass, "query_result", VALUEFUNC(_wrap_IntersectionSceneQuery_query_result), -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, "get_shadow_textures", VALUEFUNC(_wrap_ShadowTextureManager_get_shadow_textures), -1);
  rb_define_method(SwigClassShadowTextureManager.klass, "get_null_shadow_texture", VALUEFUNC(_wrap_ShadowTextureManager_get_null_shadow_texture), -1);
  rb_define_method(SwigClassShadowTextureManager.klass, "clear_unused", VALUEFUNC(_wrap_ShadowTextureManager_clear_unused), -1);
  rb_define_method(SwigClassShadowTextureManager.klass, "clear", VALUEFUNC(_wrap_ShadowTextureManager_clear), -1);
  rb_define_singleton_method(SwigClassShadowTextureManager.klass, "get_singleton", VALUEFUNC(_wrap_ShadowTextureManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassShadowTextureManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_ShadowTextureManager_get_singleton_ptr), -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, "merge_non_rendered_but_in_frustum", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_merge_non_rendered_but_in_frustum), -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, "prepare_shadow_textures", VALUEFUNC(_wrap_SceneManager_prepare_shadow_textures), -1);
  rb_define_method(SwigClassSceneManager.klass, "_pause_rendering", VALUEFUNC(_wrap_SceneManager__pause_rendering), -1);
  rb_define_method(SwigClassSceneManager.klass, "_resume_rendering", VALUEFUNC(_wrap_SceneManager__resume_rendering), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_name", VALUEFUNC(_wrap_SceneManager_get_name), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_type_name", VALUEFUNC(_wrap_SceneManager_get_type_name), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_camera", VALUEFUNC(_wrap_SceneManager_create_camera), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_camera", VALUEFUNC(_wrap_SceneManager_get_camera), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_camera", VALUEFUNC(_wrap_SceneManager_has_camera), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_camera", VALUEFUNC(_wrap_SceneManager_destroy_camera), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_cameras", VALUEFUNC(_wrap_SceneManager_destroy_all_cameras), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_light", VALUEFUNC(_wrap_SceneManager_create_light), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_light", VALUEFUNC(_wrap_SceneManager_get_light), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_light", VALUEFUNC(_wrap_SceneManager_has_light), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_light_clipping_planes", VALUEFUNC(_wrap_SceneManager_get_light_clipping_planes), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_light_scissor_rect", VALUEFUNC(_wrap_SceneManager_get_light_scissor_rect), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_light", VALUEFUNC(_wrap_SceneManager_destroy_light), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_lights", VALUEFUNC(_wrap_SceneManager_destroy_all_lights), -1);
  rb_define_method(SwigClassSceneManager.klass, "_notify_lights_dirty", VALUEFUNC(_wrap_SceneManager__notify_lights_dirty), -1);
  rb_define_method(SwigClassSceneManager.klass, "_get_lights_dirty_counter", VALUEFUNC(_wrap_SceneManager__get_lights_dirty_counter), -1);
  rb_define_method(SwigClassSceneManager.klass, "_get_lights_affecting_frustum", VALUEFUNC(_wrap_SceneManager__get_lights_affecting_frustum), -1);
  rb_define_method(SwigClassSceneManager.klass, "_populate_light_list", VALUEFUNC(_wrap_SceneManager__populate_light_list), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_scene_node", VALUEFUNC(_wrap_SceneManager_create_scene_node), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_scene_node", VALUEFUNC(_wrap_SceneManager_destroy_scene_node), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_root_scene_node", VALUEFUNC(_wrap_SceneManager_get_root_scene_node), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_scene_node", VALUEFUNC(_wrap_SceneManager_get_scene_node), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_scene_node", VALUEFUNC(_wrap_SceneManager_has_scene_node), -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, "create_entity", VALUEFUNC(_wrap_SceneManager_create_entity), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_entity", VALUEFUNC(_wrap_SceneManager_get_entity), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_entity", VALUEFUNC(_wrap_SceneManager_has_entity), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_entity", VALUEFUNC(_wrap_SceneManager_destroy_entity), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_entities", VALUEFUNC(_wrap_SceneManager_destroy_all_entities), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_manual_object", VALUEFUNC(_wrap_SceneManager_create_manual_object), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_manual_object", VALUEFUNC(_wrap_SceneManager_get_manual_object), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_manual_object", VALUEFUNC(_wrap_SceneManager_has_manual_object), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_manual_object", VALUEFUNC(_wrap_SceneManager_destroy_manual_object), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_manual_objects", VALUEFUNC(_wrap_SceneManager_destroy_all_manual_objects), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_billboard_chain", VALUEFUNC(_wrap_SceneManager_create_billboard_chain), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_billboard_chain", VALUEFUNC(_wrap_SceneManager_get_billboard_chain), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_billboard_chain", VALUEFUNC(_wrap_SceneManager_has_billboard_chain), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_billboard_chain", VALUEFUNC(_wrap_SceneManager_destroy_billboard_chain), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_billboard_chains", VALUEFUNC(_wrap_SceneManager_destroy_all_billboard_chains), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_ribbon_trail", VALUEFUNC(_wrap_SceneManager_create_ribbon_trail), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_ribbon_trail", VALUEFUNC(_wrap_SceneManager_get_ribbon_trail), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_ribbon_trail", VALUEFUNC(_wrap_SceneManager_has_ribbon_trail), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_ribbon_trail", VALUEFUNC(_wrap_SceneManager_destroy_ribbon_trail), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_ribbon_trails", VALUEFUNC(_wrap_SceneManager_destroy_all_ribbon_trails), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_particle_system", VALUEFUNC(_wrap_SceneManager_create_particle_system), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_particle_system", VALUEFUNC(_wrap_SceneManager_get_particle_system), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_particle_system", VALUEFUNC(_wrap_SceneManager_has_particle_system), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_particle_system", VALUEFUNC(_wrap_SceneManager_destroy_particle_system), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_particle_systems", VALUEFUNC(_wrap_SceneManager_destroy_all_particle_systems), -1);
  rb_define_method(SwigClassSceneManager.klass, "clear_scene", VALUEFUNC(_wrap_SceneManager_clear_scene), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_ambient_light", VALUEFUNC(_wrap_SceneManager_set_ambient_light), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_ambient_light", VALUEFUNC(_wrap_SceneManager_get_ambient_light), -1);
  rb_define_method(SwigClassSceneManager.klass, "prepare_world_geometry", VALUEFUNC(_wrap_SceneManager_prepare_world_geometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_world_geometry", VALUEFUNC(_wrap_SceneManager_set_world_geometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "estimate_world_geometry", VALUEFUNC(_wrap_SceneManager_estimate_world_geometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_suggested_viewpoint", VALUEFUNC(_wrap_SceneManager_get_suggested_viewpoint), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_option", VALUEFUNC(_wrap_SceneManager_set_option), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_option", VALUEFUNC(_wrap_SceneManager_get_option), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_option", VALUEFUNC(_wrap_SceneManager_has_option), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_option_values", VALUEFUNC(_wrap_SceneManager_get_option_values), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_option_keys", VALUEFUNC(_wrap_SceneManager_get_option_keys), -1);
  rb_define_method(SwigClassSceneManager.klass, "_update_scene_graph", VALUEFUNC(_wrap_SceneManager__update_scene_graph), -1);
  rb_define_method(SwigClassSceneManager.klass, "_find_visible_objects", VALUEFUNC(_wrap_SceneManager__find_visible_objects), -1);
  rb_define_method(SwigClassSceneManager.klass, "_apply_scene_animations", VALUEFUNC(_wrap_SceneManager__apply_scene_animations), -1);
  rb_define_method(SwigClassSceneManager.klass, "_render_visible_objects", VALUEFUNC(_wrap_SceneManager__render_visible_objects), -1);
  rb_define_method(SwigClassSceneManager.klass, "_render_scene", VALUEFUNC(_wrap_SceneManager__render_scene), -1);
  rb_define_method(SwigClassSceneManager.klass, "_queue_skies_for_rendering", VALUEFUNC(_wrap_SceneManager__queue_skies_for_rendering), -1);
  rb_define_method(SwigClassSceneManager.klass, "_set_destination_render_system", VALUEFUNC(_wrap_SceneManager__set_destination_render_system), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_sky_plane", VALUEFUNC(_wrap_SceneManager_set_sky_plane), -1);
  rb_define_method(SwigClassSceneManager.klass, "_set_sky_plane", VALUEFUNC(_wrap_SceneManager__set_sky_plane), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_sky_plane_enabled", VALUEFUNC(_wrap_SceneManager_set_sky_plane_enabled), -1);
  rb_define_method(SwigClassSceneManager.klass, "is_sky_plane_enabled", VALUEFUNC(_wrap_SceneManager_is_sky_plane_enabled), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_sky_plane_node", VALUEFUNC(_wrap_SceneManager_get_sky_plane_node), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_sky_plane_gen_parameters", VALUEFUNC(_wrap_SceneManager_get_sky_plane_gen_parameters), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_sky_box", VALUEFUNC(_wrap_SceneManager_set_sky_box), -1);
  rb_define_method(SwigClassSceneManager.klass, "_set_sky_box", VALUEFUNC(_wrap_SceneManager__set_sky_box), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_sky_box_enabled", VALUEFUNC(_wrap_SceneManager_set_sky_box_enabled), -1);
  rb_define_method(SwigClassSceneManager.klass, "is_sky_box_enabled", VALUEFUNC(_wrap_SceneManager_is_sky_box_enabled), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_sky_box_node", VALUEFUNC(_wrap_SceneManager_get_sky_box_node), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_sky_box_gen_parameters", VALUEFUNC(_wrap_SceneManager_get_sky_box_gen_parameters), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_sky_dome", VALUEFUNC(_wrap_SceneManager_set_sky_dome), -1);
  rb_define_method(SwigClassSceneManager.klass, "_set_sky_dome", VALUEFUNC(_wrap_SceneManager__set_sky_dome), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_sky_dome_enabled", VALUEFUNC(_wrap_SceneManager_set_sky_dome_enabled), -1);
  rb_define_method(SwigClassSceneManager.klass, "is_sky_dome_enabled", VALUEFUNC(_wrap_SceneManager_is_sky_dome_enabled), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_sky_dome_node", VALUEFUNC(_wrap_SceneManager_get_sky_dome_node), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_sky_dome_gen_parameters", VALUEFUNC(_wrap_SceneManager_get_sky_dome_gen_parameters), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_fog", VALUEFUNC(_wrap_SceneManager_set_fog), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_fog_mode", VALUEFUNC(_wrap_SceneManager_get_fog_mode), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_fog_colour", VALUEFUNC(_wrap_SceneManager_get_fog_colour), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_fog_start", VALUEFUNC(_wrap_SceneManager_get_fog_start), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_fog_end", VALUEFUNC(_wrap_SceneManager_get_fog_end), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_fog_density", VALUEFUNC(_wrap_SceneManager_get_fog_density), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_billboard_set", VALUEFUNC(_wrap_SceneManager_create_billboard_set), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_billboard_set", VALUEFUNC(_wrap_SceneManager_get_billboard_set), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_billboard_set", VALUEFUNC(_wrap_SceneManager_has_billboard_set), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_billboard_set", VALUEFUNC(_wrap_SceneManager_destroy_billboard_set), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_billboard_sets", VALUEFUNC(_wrap_SceneManager_destroy_all_billboard_sets), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_display_scene_nodes", VALUEFUNC(_wrap_SceneManager_set_display_scene_nodes), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_display_scene_nodes", VALUEFUNC(_wrap_SceneManager_get_display_scene_nodes), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_animation", VALUEFUNC(_wrap_SceneManager_create_animation), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_animation", VALUEFUNC(_wrap_SceneManager_get_animation), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_animation", VALUEFUNC(_wrap_SceneManager_has_animation), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_animation", VALUEFUNC(_wrap_SceneManager_destroy_animation), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_animations", VALUEFUNC(_wrap_SceneManager_destroy_all_animations), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_animation_state", VALUEFUNC(_wrap_SceneManager_create_animation_state), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_animation_state", VALUEFUNC(_wrap_SceneManager_get_animation_state), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_animation_state", VALUEFUNC(_wrap_SceneManager_has_animation_state), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_animation_state", VALUEFUNC(_wrap_SceneManager_destroy_animation_state), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_animation_states", VALUEFUNC(_wrap_SceneManager_destroy_all_animation_states), -1);
  rb_define_method(SwigClassSceneManager.klass, "manual_render", VALUEFUNC(_wrap_SceneManager_manual_render), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_render_queue", VALUEFUNC(_wrap_SceneManager_get_render_queue), -1);
  rb_define_method(SwigClassSceneManager.klass, "add_render_queue_listener", VALUEFUNC(_wrap_SceneManager_add_render_queue_listener), -1);
  rb_define_method(SwigClassSceneManager.klass, "remove_render_queue_listener", VALUEFUNC(_wrap_SceneManager_remove_render_queue_listener), -1);
  rb_define_method(SwigClassSceneManager.klass, "add_render_object_listener", VALUEFUNC(_wrap_SceneManager_add_render_object_listener), -1);
  rb_define_method(SwigClassSceneManager.klass, "remove_render_object_listener", VALUEFUNC(_wrap_SceneManager_remove_render_object_listener), -1);
  rb_define_method(SwigClassSceneManager.klass, "add_special_case_render_queue", VALUEFUNC(_wrap_SceneManager_add_special_case_render_queue), -1);
  rb_define_method(SwigClassSceneManager.klass, "remove_special_case_render_queue", VALUEFUNC(_wrap_SceneManager_remove_special_case_render_queue), -1);
  rb_define_method(SwigClassSceneManager.klass, "clear_special_case_render_queues", VALUEFUNC(_wrap_SceneManager_clear_special_case_render_queues), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_special_case_render_queue_mode", VALUEFUNC(_wrap_SceneManager_set_special_case_render_queue_mode), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_special_case_render_queue_mode", VALUEFUNC(_wrap_SceneManager_get_special_case_render_queue_mode), -1);
  rb_define_method(SwigClassSceneManager.klass, "is_render_queue_to_be_processed", VALUEFUNC(_wrap_SceneManager_is_render_queue_to_be_processed), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_world_geometry_render_queue", VALUEFUNC(_wrap_SceneManager_set_world_geometry_render_queue), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_world_geometry_render_queue", VALUEFUNC(_wrap_SceneManager_get_world_geometry_render_queue), -1);
  rb_define_method(SwigClassSceneManager.klass, "show_bounding_boxes", VALUEFUNC(_wrap_SceneManager_show_bounding_boxes), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_show_bounding_boxes", VALUEFUNC(_wrap_SceneManager_get_show_bounding_boxes), -1);
  rb_define_method(SwigClassSceneManager.klass, "_notify_autotracking_scene_node", VALUEFUNC(_wrap_SceneManager__notify_autotracking_scene_node), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_aabbquery", VALUEFUNC(_wrap_SceneManager_create_aabbquery), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_sphere_query", VALUEFUNC(_wrap_SceneManager_create_sphere_query), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_plane_bounded_volume_query", VALUEFUNC(_wrap_SceneManager_create_plane_bounded_volume_query), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_ray_query", VALUEFUNC(_wrap_SceneManager_create_ray_query), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_intersection_query", VALUEFUNC(_wrap_SceneManager_create_intersection_query), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_query", VALUEFUNC(_wrap_SceneManager_destroy_query), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_camera_iterator", VALUEFUNC(_wrap_SceneManager_get_camera_iterator), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_animation_iterator", VALUEFUNC(_wrap_SceneManager_get_animation_iterator), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_animation_state_iterator", VALUEFUNC(_wrap_SceneManager_get_animation_state_iterator), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_technique", VALUEFUNC(_wrap_SceneManager_set_shadow_technique), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_technique", VALUEFUNC(_wrap_SceneManager_get_shadow_technique), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_show_debug_shadows", VALUEFUNC(_wrap_SceneManager_set_show_debug_shadows), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_show_debug_shadows", VALUEFUNC(_wrap_SceneManager_get_show_debug_shadows), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_colour", VALUEFUNC(_wrap_SceneManager_set_shadow_colour), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_colour", VALUEFUNC(_wrap_SceneManager_get_shadow_colour), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_directional_light_extrusion_distance", VALUEFUNC(_wrap_SceneManager_set_shadow_directional_light_extrusion_distance), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_directional_light_extrusion_distance", VALUEFUNC(_wrap_SceneManager_get_shadow_directional_light_extrusion_distance), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_far_distance", VALUEFUNC(_wrap_SceneManager_set_shadow_far_distance), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_far_distance", VALUEFUNC(_wrap_SceneManager_get_shadow_far_distance), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_far_distance_squared", VALUEFUNC(_wrap_SceneManager_get_shadow_far_distance_squared), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_index_buffer_size", VALUEFUNC(_wrap_SceneManager_set_shadow_index_buffer_size), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_index_buffer_size", VALUEFUNC(_wrap_SceneManager_get_shadow_index_buffer_size), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_texture_size", VALUEFUNC(_wrap_SceneManager_set_shadow_texture_size), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_texture_config", VALUEFUNC(_wrap_SceneManager_set_shadow_texture_config), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_texture_config_iterator", VALUEFUNC(_wrap_SceneManager_get_shadow_texture_config_iterator), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_texture_pixel_format", VALUEFUNC(_wrap_SceneManager_set_shadow_texture_pixel_format), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_texture_fsaa", VALUEFUNC(_wrap_SceneManager_set_shadow_texture_fsaa), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_texture_count", VALUEFUNC(_wrap_SceneManager_set_shadow_texture_count), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_texture_count", VALUEFUNC(_wrap_SceneManager_get_shadow_texture_count), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_texture_count_per_light_type", VALUEFUNC(_wrap_SceneManager_set_shadow_texture_count_per_light_type), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_texture_count_per_light_type", VALUEFUNC(_wrap_SceneManager_get_shadow_texture_count_per_light_type), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_texture_settings", VALUEFUNC(_wrap_SceneManager_set_shadow_texture_settings), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_texture", VALUEFUNC(_wrap_SceneManager_get_shadow_texture), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_dir_light_texture_offset", VALUEFUNC(_wrap_SceneManager_set_shadow_dir_light_texture_offset), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_dir_light_texture_offset", VALUEFUNC(_wrap_SceneManager_get_shadow_dir_light_texture_offset), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_texture_fade_start", VALUEFUNC(_wrap_SceneManager_set_shadow_texture_fade_start), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_texture_fade_end", VALUEFUNC(_wrap_SceneManager_set_shadow_texture_fade_end), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_texture_self_shadow", VALUEFUNC(_wrap_SceneManager_set_shadow_texture_self_shadow), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_texture_self_shadow", VALUEFUNC(_wrap_SceneManager_get_shadow_texture_self_shadow), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_texture_caster_material", VALUEFUNC(_wrap_SceneManager_set_shadow_texture_caster_material), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_texture_receiver_material", VALUEFUNC(_wrap_SceneManager_set_shadow_texture_receiver_material), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_caster_render_back_faces", VALUEFUNC(_wrap_SceneManager_set_shadow_caster_render_back_faces), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_caster_render_back_faces", VALUEFUNC(_wrap_SceneManager_get_shadow_caster_render_back_faces), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_camera_setup", VALUEFUNC(_wrap_SceneManager_set_shadow_camera_setup), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_camera_setup", VALUEFUNC(_wrap_SceneManager_get_shadow_camera_setup), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_use_infinite_far_plane", VALUEFUNC(_wrap_SceneManager_set_shadow_use_infinite_far_plane), -1);
  rb_define_method(SwigClassSceneManager.klass, "is_shadow_technique_stencil_based", VALUEFUNC(_wrap_SceneManager_is_shadow_technique_stencil_based), -1);
  rb_define_method(SwigClassSceneManager.klass, "is_shadow_technique_texture_based", VALUEFUNC(_wrap_SceneManager_is_shadow_technique_texture_based), -1);
  rb_define_method(SwigClassSceneManager.klass, "is_shadow_technique_modulative", VALUEFUNC(_wrap_SceneManager_is_shadow_technique_modulative), -1);
  rb_define_method(SwigClassSceneManager.klass, "is_shadow_technique_additive", VALUEFUNC(_wrap_SceneManager_is_shadow_technique_additive), -1);
  rb_define_method(SwigClassSceneManager.klass, "is_shadow_technique_integrated", VALUEFUNC(_wrap_SceneManager_is_shadow_technique_integrated), -1);
  rb_define_method(SwigClassSceneManager.klass, "is_shadow_technique_in_use", VALUEFUNC(_wrap_SceneManager_is_shadow_technique_in_use), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_shadow_use_light_clip_planes", VALUEFUNC(_wrap_SceneManager_set_shadow_use_light_clip_planes), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_use_light_clip_planes", VALUEFUNC(_wrap_SceneManager_get_shadow_use_light_clip_planes), -1);
  rb_define_method(SwigClassSceneManager.klass, "_set_active_compositor_chain", VALUEFUNC(_wrap_SceneManager__set_active_compositor_chain), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_late_material_resolving", VALUEFUNC(_wrap_SceneManager_set_late_material_resolving), -1);
  rb_define_method(SwigClassSceneManager.klass, "is_late_material_resolving", VALUEFUNC(_wrap_SceneManager_is_late_material_resolving), -1);
  rb_define_method(SwigClassSceneManager.klass, "_get_active_compositor_chain", VALUEFUNC(_wrap_SceneManager__get_active_compositor_chain), -1);
  rb_define_method(SwigClassSceneManager.klass, "add_listener", VALUEFUNC(_wrap_SceneManager_add_listener), -1);
  rb_define_method(SwigClassSceneManager.klass, "remove_listener", VALUEFUNC(_wrap_SceneManager_remove_listener), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_static_geometry", VALUEFUNC(_wrap_SceneManager_create_static_geometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_static_geometry", VALUEFUNC(_wrap_SceneManager_get_static_geometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_static_geometry", VALUEFUNC(_wrap_SceneManager_has_static_geometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_static_geometry", VALUEFUNC(_wrap_SceneManager_destroy_static_geometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_static_geometry", VALUEFUNC(_wrap_SceneManager_destroy_all_static_geometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_instanced_geometry", VALUEFUNC(_wrap_SceneManager_create_instanced_geometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_instanced_geometry", VALUEFUNC(_wrap_SceneManager_get_instanced_geometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_instanced_geometry", VALUEFUNC(_wrap_SceneManager_destroy_instanced_geometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_instanced_geometry", VALUEFUNC(_wrap_SceneManager_destroy_all_instanced_geometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_instance_manager", VALUEFUNC(_wrap_SceneManager_create_instance_manager), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_instance_manager", VALUEFUNC(_wrap_SceneManager_get_instance_manager), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_instance_manager", VALUEFUNC(_wrap_SceneManager_has_instance_manager), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_instance_manager", VALUEFUNC(_wrap_SceneManager_destroy_instance_manager), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_instance_managers", VALUEFUNC(_wrap_SceneManager_destroy_all_instance_managers), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_num_instances_per_batch", VALUEFUNC(_wrap_SceneManager_get_num_instances_per_batch), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_instanced_entity", VALUEFUNC(_wrap_SceneManager_create_instanced_entity), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_instanced_entity", VALUEFUNC(_wrap_SceneManager_destroy_instanced_entity), -1);
  rb_define_method(SwigClassSceneManager.klass, "_add_dirty_instance_manager", VALUEFUNC(_wrap_SceneManager__add_dirty_instance_manager), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_movable_object", VALUEFUNC(_wrap_SceneManager_destroy_movable_object), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_movable_objects_by_type", VALUEFUNC(_wrap_SceneManager_destroy_all_movable_objects_by_type), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroy_all_movable_objects", VALUEFUNC(_wrap_SceneManager_destroy_all_movable_objects), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_movable_object", VALUEFUNC(_wrap_SceneManager_get_movable_object), -1);
  rb_define_method(SwigClassSceneManager.klass, "has_movable_object", VALUEFUNC(_wrap_SceneManager_has_movable_object), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_movable_object_iterator", VALUEFUNC(_wrap_SceneManager_get_movable_object_iterator), -1);
  rb_define_method(SwigClassSceneManager.klass, "inject_movable_object", VALUEFUNC(_wrap_SceneManager_inject_movable_object), -1);
  rb_define_method(SwigClassSceneManager.klass, "extract_movable_object", VALUEFUNC(_wrap_SceneManager_extract_movable_object), -1);
  rb_define_method(SwigClassSceneManager.klass, "extract_all_movable_objects_by_type", VALUEFUNC(_wrap_SceneManager_extract_all_movable_objects_by_type), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_visibility_mask", VALUEFUNC(_wrap_SceneManager_set_visibility_mask), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_visibility_mask", VALUEFUNC(_wrap_SceneManager_get_visibility_mask), -1);
  rb_define_method(SwigClassSceneManager.klass, "_get_combined_visibility_mask", VALUEFUNC(_wrap_SceneManager__get_combined_visibility_mask), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_find_visible_objects", VALUEFUNC(_wrap_SceneManager_set_find_visible_objects), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_find_visible_objects", VALUEFUNC(_wrap_SceneManager_get_find_visible_objects), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_normalise_normals_on_scale", VALUEFUNC(_wrap_SceneManager_set_normalise_normals_on_scale), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_normalise_normals_on_scale", VALUEFUNC(_wrap_SceneManager_get_normalise_normals_on_scale), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_flip_culling_on_negative_scale", VALUEFUNC(_wrap_SceneManager_set_flip_culling_on_negative_scale), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_flip_culling_on_negative_scale", VALUEFUNC(_wrap_SceneManager_get_flip_culling_on_negative_scale), -1);
  rb_define_method(SwigClassSceneManager.klass, "_inject_render_with_pass", VALUEFUNC(_wrap_SceneManager__inject_render_with_pass), -1);
  rb_define_method(SwigClassSceneManager.klass, "_suppress_render_state_changes", VALUEFUNC(_wrap_SceneManager__suppress_render_state_changes), -1);
  rb_define_method(SwigClassSceneManager.klass, "_are_render_state_changes_suppressed", VALUEFUNC(_wrap_SceneManager__are_render_state_changes_suppressed), -1);
  rb_define_method(SwigClassSceneManager.klass, "_set_pass", VALUEFUNC(_wrap_SceneManager__set_pass), -1);
  rb_define_method(SwigClassSceneManager.klass, "_mark_gpu_params_dirty", VALUEFUNC(_wrap_SceneManager__mark_gpu_params_dirty), -1);
  rb_define_method(SwigClassSceneManager.klass, "_suppress_shadows", VALUEFUNC(_wrap_SceneManager__suppress_shadows), -1);
  rb_define_method(SwigClassSceneManager.klass, "_are_shadows_suppressed", VALUEFUNC(_wrap_SceneManager__are_shadows_suppressed), -1);
  rb_define_method(SwigClassSceneManager.klass, "_render_queue_group_objects", VALUEFUNC(_wrap_SceneManager__render_queue_group_objects), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_queued_renderable_visitor", VALUEFUNC(_wrap_SceneManager_set_queued_renderable_visitor), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_queued_renderable_visitor", VALUEFUNC(_wrap_SceneManager_get_queued_renderable_visitor), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_destination_render_system", VALUEFUNC(_wrap_SceneManager_get_destination_render_system), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_current_viewport", VALUEFUNC(_wrap_SceneManager_get_current_viewport), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_visible_objects_bounds_info", VALUEFUNC(_wrap_SceneManager_get_visible_objects_bounds_info), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_shadow_caster_bounds_info", VALUEFUNC(_wrap_SceneManager_get_shadow_caster_bounds_info), -1);
  rb_define_method(SwigClassSceneManager.klass, "set_camera_relative_rendering", VALUEFUNC(_wrap_SceneManager_set_camera_relative_rendering), -1);
  rb_define_method(SwigClassSceneManager.klass, "get_camera_relative_rendering", VALUEFUNC(_wrap_SceneManager_get_camera_relative_rendering), -1);
  rb_define_method(SwigClassSceneManager.klass, "add_lod_listener", VALUEFUNC(_wrap_SceneManager_add_lod_listener), -1);
  rb_define_method(SwigClassSceneManager.klass, "remove_lod_listener", VALUEFUNC(_wrap_SceneManager_remove_lod_listener), -1);
  rb_define_method(SwigClassSceneManager.klass, "_notify_movable_object_lod_changed", VALUEFUNC(_wrap_SceneManager__notify_movable_object_lod_changed), -1);
  rb_define_method(SwigClassSceneManager.klass, "_notify_entity_mesh_lod_changed", VALUEFUNC(_wrap_SceneManager__notify_entity_mesh_lod_changed), -1);
  rb_define_method(SwigClassSceneManager.klass, "_notify_entity_material_lod_changed", VALUEFUNC(_wrap_SceneManager__notify_entity_material_lod_changed), -1);
  rb_define_method(SwigClassSceneManager.klass, "_handle_lod_events", VALUEFUNC(_wrap_SceneManager__handle_lod_events), -1);
  rb_define_method(SwigClassSceneManager.klass, "create_movable_object", VALUEFUNC(_wrap_SceneManager_create_movable_object), -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, "get_meta_data", VALUEFUNC(_wrap_SceneManagerFactory_get_meta_data), -1);
  rb_define_method(SwigClassSceneManagerFactory.klass, "create_instance", VALUEFUNC(_wrap_SceneManagerFactory_create_instance), -1);
  rb_define_method(SwigClassSceneManagerFactory.klass, "destroy_instance", VALUEFUNC(_wrap_SceneManagerFactory_destroy_instance), -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, "save_config", VALUEFUNC(_wrap_Root_save_config), -1);
  rb_define_method(SwigClassRoot.klass, "restore_config", VALUEFUNC(_wrap_Root_restore_config), -1);
  rb_define_method(SwigClassRoot.klass, "show_config_dialog", VALUEFUNC(_wrap_Root_show_config_dialog), -1);
  rb_define_method(SwigClassRoot.klass, "add_render_system", VALUEFUNC(_wrap_Root_add_render_system), -1);
  rb_define_method(SwigClassRoot.klass, "get_available_renderers", VALUEFUNC(_wrap_Root_get_available_renderers), -1);
  rb_define_method(SwigClassRoot.klass, "get_render_system_by_name", VALUEFUNC(_wrap_Root_get_render_system_by_name), -1);
  rb_define_method(SwigClassRoot.klass, "set_render_system", VALUEFUNC(_wrap_Root_set_render_system), -1);
  rb_define_method(SwigClassRoot.klass, "get_render_system", VALUEFUNC(_wrap_Root_get_render_system), -1);
  rb_define_method(SwigClassRoot.klass, "initialise", VALUEFUNC(_wrap_Root_initialise), -1);
  rb_define_method(SwigClassRoot.klass, "is_initialised", VALUEFUNC(_wrap_Root_is_initialised), -1);
  rb_define_method(SwigClassRoot.klass, "use_custom_render_system_capabilities", VALUEFUNC(_wrap_Root_use_custom_render_system_capabilities), -1);
  rb_define_method(SwigClassRoot.klass, "get_remove_render_queue_structures_on_clear", VALUEFUNC(_wrap_Root_get_remove_render_queue_structures_on_clear), -1);
  rb_define_method(SwigClassRoot.klass, "set_remove_render_queue_structures_on_clear", VALUEFUNC(_wrap_Root_set_remove_render_queue_structures_on_clear), -1);
  rb_define_method(SwigClassRoot.klass, "add_scene_manager_factory", VALUEFUNC(_wrap_Root_add_scene_manager_factory), -1);
  rb_define_method(SwigClassRoot.klass, "remove_scene_manager_factory", VALUEFUNC(_wrap_Root_remove_scene_manager_factory), -1);
  rb_define_method(SwigClassRoot.klass, "get_scene_manager_meta_data", VALUEFUNC(_wrap_Root_get_scene_manager_meta_data), -1);
  rb_define_method(SwigClassRoot.klass, "get_scene_manager_meta_data_iterator", VALUEFUNC(_wrap_Root_get_scene_manager_meta_data_iterator), -1);
  rb_define_method(SwigClassRoot.klass, "create_scene_manager", VALUEFUNC(_wrap_Root_create_scene_manager), -1);
  rb_define_method(SwigClassRoot.klass, "destroy_scene_manager", VALUEFUNC(_wrap_Root_destroy_scene_manager), -1);
  rb_define_method(SwigClassRoot.klass, "get_scene_manager", VALUEFUNC(_wrap_Root_get_scene_manager), -1);
  rb_define_method(SwigClassRoot.klass, "has_scene_manager", VALUEFUNC(_wrap_Root_has_scene_manager), -1);
  rb_define_method(SwigClassRoot.klass, "get_scene_manager_iterator", VALUEFUNC(_wrap_Root_get_scene_manager_iterator), -1);
  rb_define_method(SwigClassRoot.klass, "get_texture_manager", VALUEFUNC(_wrap_Root_get_texture_manager), -1);
  rb_define_method(SwigClassRoot.klass, "get_mesh_manager", VALUEFUNC(_wrap_Root_get_mesh_manager), -1);
  rb_define_method(SwigClassRoot.klass, "get_error_description", VALUEFUNC(_wrap_Root_get_error_description), -1);
  rb_define_method(SwigClassRoot.klass, "add_frame_listener", VALUEFUNC(_wrap_Root_add_frame_listener), -1);
  rb_define_method(SwigClassRoot.klass, "remove_frame_listener", VALUEFUNC(_wrap_Root_remove_frame_listener), -1);
  rb_define_method(SwigClassRoot.klass, "queue_end_rendering", VALUEFUNC(_wrap_Root_queue_end_rendering), -1);
  rb_define_method(SwigClassRoot.klass, "start_rendering", VALUEFUNC(_wrap_Root_start_rendering), -1);
  rb_define_method(SwigClassRoot.klass, "render_one_frame", VALUEFUNC(_wrap_Root_render_one_frame), -1);
  rb_define_method(SwigClassRoot.klass, "shutdown", VALUEFUNC(_wrap_Root_shutdown), -1);
  rb_define_method(SwigClassRoot.klass, "add_resource_location", VALUEFUNC(_wrap_Root_add_resource_location), -1);
  rb_define_method(SwigClassRoot.klass, "remove_resource_location", VALUEFUNC(_wrap_Root_remove_resource_location), -1);
  rb_define_method(SwigClassRoot.klass, "create_file_stream", VALUEFUNC(_wrap_Root_create_file_stream), -1);
  rb_define_method(SwigClassRoot.klass, "open_file_stream", VALUEFUNC(_wrap_Root_open_file_stream), -1);
  rb_define_method(SwigClassRoot.klass, "convert_colour_value", VALUEFUNC(_wrap_Root_convert_colour_value), -1);
  rb_define_method(SwigClassRoot.klass, "get_auto_created_window", VALUEFUNC(_wrap_Root_get_auto_created_window), -1);
  rb_define_method(SwigClassRoot.klass, "create_render_window", VALUEFUNC(_wrap_Root_create_render_window), -1);
  rb_define_method(SwigClassRoot.klass, "create_render_windows", VALUEFUNC(_wrap_Root_create_render_windows), -1);
  rb_define_method(SwigClassRoot.klass, "detach_render_target", VALUEFUNC(_wrap_Root_detach_render_target), -1);
  rb_define_method(SwigClassRoot.klass, "destroy_render_target", VALUEFUNC(_wrap_Root_destroy_render_target), -1);
  rb_define_method(SwigClassRoot.klass, "get_render_target", VALUEFUNC(_wrap_Root_get_render_target), -1);
  rb_define_method(SwigClassRoot.klass, "load_plugin", VALUEFUNC(_wrap_Root_load_plugin), -1);
  rb_define_method(SwigClassRoot.klass, "unload_plugin", VALUEFUNC(_wrap_Root_unload_plugin), -1);
  rb_define_method(SwigClassRoot.klass, "install_plugin", VALUEFUNC(_wrap_Root_install_plugin), -1);
  rb_define_method(SwigClassRoot.klass, "uninstall_plugin", VALUEFUNC(_wrap_Root_uninstall_plugin), -1);
  rb_define_method(SwigClassRoot.klass, "get_installed_plugins", VALUEFUNC(_wrap_Root_get_installed_plugins), -1);
  rb_define_method(SwigClassRoot.klass, "get_timer", VALUEFUNC(_wrap_Root_get_timer), -1);
  rb_define_method(SwigClassRoot.klass, "_fire_frame_started", VALUEFUNC(_wrap_Root__fire_frame_started), -1);
  rb_define_method(SwigClassRoot.klass, "_fire_frame_rendering_queued", VALUEFUNC(_wrap_Root__fire_frame_rendering_queued), -1);
  rb_define_method(SwigClassRoot.klass, "_fire_frame_ended", VALUEFUNC(_wrap_Root__fire_frame_ended), -1);
  rb_define_method(SwigClassRoot.klass, "get_next_frame_number", VALUEFUNC(_wrap_Root_get_next_frame_number), -1);
  rb_define_method(SwigClassRoot.klass, "_get_current_scene_manager", VALUEFUNC(_wrap_Root__get_current_scene_manager), -1);
  rb_define_method(SwigClassRoot.klass, "_push_current_scene_manager", VALUEFUNC(_wrap_Root__push_current_scene_manager), -1);
  rb_define_method(SwigClassRoot.klass, "_pop_current_scene_manager", VALUEFUNC(_wrap_Root__pop_current_scene_manager), -1);
  rb_define_method(SwigClassRoot.klass, "_update_all_render_targets", VALUEFUNC(_wrap_Root__update_all_render_targets), -1);
  rb_define_method(SwigClassRoot.klass, "create_render_queue_invocation_sequence", VALUEFUNC(_wrap_Root_create_render_queue_invocation_sequence), -1);
  rb_define_method(SwigClassRoot.klass, "get_render_queue_invocation_sequence", VALUEFUNC(_wrap_Root_get_render_queue_invocation_sequence), -1);
  rb_define_method(SwigClassRoot.klass, "destroy_render_queue_invocation_sequence", VALUEFUNC(_wrap_Root_destroy_render_queue_invocation_sequence), -1);
  rb_define_method(SwigClassRoot.klass, "destroy_all_render_queue_invocation_sequences", VALUEFUNC(_wrap_Root_destroy_all_render_queue_invocation_sequences), -1);
  rb_define_singleton_method(SwigClassRoot.klass, "get_singleton", VALUEFUNC(_wrap_Root_get_singleton), -1);
  rb_define_singleton_method(SwigClassRoot.klass, "get_singleton_ptr", VALUEFUNC(_wrap_Root_get_singleton_ptr), -1);
  rb_define_method(SwigClassRoot.klass, "clear_event_times", VALUEFUNC(_wrap_Root_clear_event_times), -1);
  rb_define_method(SwigClassRoot.klass, "set_frame_smoothing_period", VALUEFUNC(_wrap_Root_set_frame_smoothing_period), -1);
  rb_define_method(SwigClassRoot.klass, "get_frame_smoothing_period", VALUEFUNC(_wrap_Root_get_frame_smoothing_period), -1);
  rb_define_method(SwigClassRoot.klass, "add_movable_object_factory", VALUEFUNC(_wrap_Root_add_movable_object_factory), -1);
  rb_define_method(SwigClassRoot.klass, "remove_movable_object_factory", VALUEFUNC(_wrap_Root_remove_movable_object_factory), -1);
  rb_define_method(SwigClassRoot.klass, "has_movable_object_factory", VALUEFUNC(_wrap_Root_has_movable_object_factory), -1);
  rb_define_method(SwigClassRoot.klass, "get_movable_object_factory", VALUEFUNC(_wrap_Root_get_movable_object_factory), -1);
  rb_define_method(SwigClassRoot.klass, "_allocate_next_movable_object_type_flag", VALUEFUNC(_wrap_Root__allocate_next_movable_object_type_flag), -1);
  rb_define_method(SwigClassRoot.klass, "get_movable_object_factory_iterator", VALUEFUNC(_wrap_Root_get_movable_object_factory_iterator), -1);
  rb_define_method(SwigClassRoot.klass, "get_display_monitor_count", VALUEFUNC(_wrap_Root_get_display_monitor_count), -1);
  rb_define_method(SwigClassRoot.klass, "get_work_queue", VALUEFUNC(_wrap_Root_get_work_queue), -1);
  rb_define_method(SwigClassRoot.klass, "set_work_queue", VALUEFUNC(_wrap_Root_set_work_queue), -1);
  rb_define_method(SwigClassRoot.klass, "set_blend_indices_gpu_redundant", VALUEFUNC(_wrap_Root_set_blend_indices_gpu_redundant), -1);
  rb_define_method(SwigClassRoot.klass, "is_blend_indices_gpu_redundant", VALUEFUNC(_wrap_Root_is_blend_indices_gpu_redundant), -1);
  rb_define_method(SwigClassRoot.klass, "set_blend_weights_gpu_redundant", VALUEFUNC(_wrap_Root_set_blend_weights_gpu_redundant), -1);
  rb_define_method(SwigClassRoot.klass, "is_blend_weights_gpu_redundant", VALUEFUNC(_wrap_Root_is_blend_weights_gpu_redundant), -1);
  rb_define_method(SwigClassRoot.klass, "set_default_min_pixel_size", VALUEFUNC(_wrap_Root_set_default_min_pixel_size), -1);
  rb_define_method(SwigClassRoot.klass, "get_default_min_pixel_size", VALUEFUNC(_wrap_Root_get_default_min_pixel_size), -1);
  rb_define_method(SwigClassRoot.klass, "get_available_renderer_array", VALUEFUNC(_wrap_Root_get_available_renderer_array), -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, "create_instance", VALUEFUNC(_wrap_DefaultSceneManagerFactory_create_instance), -1);
  rb_define_method(SwigClassDefaultSceneManagerFactory.klass, "destroy_instance", VALUEFUNC(_wrap_DefaultSceneManagerFactory_destroy_instance), -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, "get_type_name", VALUEFUNC(_wrap_DefaultSceneManager_get_type_name), -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, "add_factory", VALUEFUNC(_wrap_SceneManagerEnumerator_add_factory), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "remove_factory", VALUEFUNC(_wrap_SceneManagerEnumerator_remove_factory), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "get_meta_data", VALUEFUNC(_wrap_SceneManagerEnumerator_get_meta_data), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "get_meta_data_iterator", VALUEFUNC(_wrap_SceneManagerEnumerator_get_meta_data_iterator), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "create_scene_manager", VALUEFUNC(_wrap_SceneManagerEnumerator_create_scene_manager), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "destroy_scene_manager", VALUEFUNC(_wrap_SceneManagerEnumerator_destroy_scene_manager), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "get_scene_manager", VALUEFUNC(_wrap_SceneManagerEnumerator_get_scene_manager), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "has_scene_manager", VALUEFUNC(_wrap_SceneManagerEnumerator_has_scene_manager), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "get_scene_manager_iterator", VALUEFUNC(_wrap_SceneManagerEnumerator_get_scene_manager_iterator), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "set_render_system", VALUEFUNC(_wrap_SceneManagerEnumerator_set_render_system), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "shutdown_all", VALUEFUNC(_wrap_SceneManagerEnumerator_shutdown_all), -1);
  rb_define_singleton_method(SwigClassSceneManagerEnumerator.klass, "get_singleton", VALUEFUNC(_wrap_SceneManagerEnumerator_get_singleton), -1);
  rb_define_singleton_method(SwigClassSceneManagerEnumerator.klass, "get_singleton_ptr", VALUEFUNC(_wrap_SceneManagerEnumerator_get_singleton_ptr), -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, "parse_chunk", VALUEFUNC(_wrap_ScriptParser_parse_chunk), -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, "get_num_translators", VALUEFUNC(_wrap_ScriptTranslatorManager_get_num_translators), -1);
  rb_define_method(SwigClassScriptTranslatorManager.klass, "get_translator", VALUEFUNC(_wrap_ScriptTranslatorManager_get_translator), -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, "translate_program_parameters", VALUEFUNC(_wrap_GpuProgramTranslator_translate_program_parameters), -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, "get_num_translators", VALUEFUNC(_wrap_BuiltinScriptTranslatorManager_get_num_translators), -1);
  rb_define_method(SwigClassBuiltinScriptTranslatorManager.klass, "get_translator", VALUEFUNC(_wrap_BuiltinScriptTranslatorManager_get_translator), -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, "get_shadow_camera", VALUEFUNC(_wrap_FocusedShadowCameraSetup_get_shadow_camera), -1);
  rb_define_method(SwigClassFocusedShadowCameraSetup.klass, "set_use_aggressive_focus_region", VALUEFUNC(_wrap_FocusedShadowCameraSetup_set_use_aggressive_focus_region), -1);
  rb_define_method(SwigClassFocusedShadowCameraSetup.klass, "get_use_aggressive_focus_region", VALUEFUNC(_wrap_FocusedShadowCameraSetup_get_use_aggressive_focus_region), -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, "get_shadow_camera", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_get_shadow_camera), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "set_optimal_adjust_factor", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_set_optimal_adjust_factor), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "get_optimal_adjust_factor", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_get_optimal_adjust_factor), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "set_use_simple_optimal_adjust", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_set_use_simple_optimal_adjust), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "get_use_simple_optimal_adjust", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_get_use_simple_optimal_adjust), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "set_camera_light_direction_threshold", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_set_camera_light_direction_threshold), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "get_camera_light_direction_threshold", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_get_camera_light_direction_threshold), -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, "calculate_split_points", VALUEFUNC(_wrap_PSSMShadowCameraSetup_calculate_split_points), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "set_split_points", VALUEFUNC(_wrap_PSSMShadowCameraSetup_set_split_points), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "set_optimal_adjust_factor", VALUEFUNC(_wrap_PSSMShadowCameraSetup_set_optimal_adjust_factor), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "set_split_padding", VALUEFUNC(_wrap_PSSMShadowCameraSetup_set_split_padding), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "get_split_padding", VALUEFUNC(_wrap_PSSMShadowCameraSetup_get_split_padding), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "get_split_count", VALUEFUNC(_wrap_PSSMShadowCameraSetup_get_split_count), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "get_shadow_camera", VALUEFUNC(_wrap_PSSMShadowCameraSetup_get_shadow_camera), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "get_split_points", VALUEFUNC(_wrap_PSSMShadowCameraSetup_get_split_points), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "get_optimal_adjust_factor", VALUEFUNC(_wrap_PSSMShadowCameraSetup_get_optimal_adjust_factor), -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, "get_shadow_camera", VALUEFUNC(_wrap_PlaneOptimalShadowCameraSetup_get_shadow_camera), -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, "get_point_light_extruder_arbvp1", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_arbvp1), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_vs_1_1", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_1_1), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_vs_4_0", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_4_0), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_vs_glsles", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_glsles), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_arbvp1", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_arbvp1), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_vs_1_1", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_1_1), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_vs_4_0", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_4_0), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_vs_glsles", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_glsles), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_arbvp_1debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_arbvp_1debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_vs_1_1debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_1_1debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_vs_4_0debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_4_0debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_vs_glsles_debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_glsles_debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_arbvp_1debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_arbvp_1debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_vs_1_1debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_1_1debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_vs_4_0debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_4_0debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_vs_glsles_debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_glsles_debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_program_source", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_program_source), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_program_name", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_program_name), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_arbvp_1finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_arbvp_1finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_vs_1_1finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_1_1finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_vs_4_0finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_4_0finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_vs_glsles_finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_glsles_finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_arbvp_1finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_arbvp_1finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_vs_1_1finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_1_1finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_vs_4_0finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_4_0finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_vs_glsles_finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_glsles_finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_arbvp_1finite_debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_arbvp_1finite_debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_vs_1_1finite_debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_1_1finite_debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_vs_4_0finite_debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_4_0finite_debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_point_light_extruder_vs_glsles_finite_debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_point_light_extruder_vs_glsles_finite_debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_arbvp_1finite_debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_arbvp_1finite_debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_vs_1_1finite_debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_1_1finite_debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_vs_4_0finite_debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_4_0finite_debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "get_directional_light_extruder_vs_glsles_finite_debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_get_directional_light_extruder_vs_glsles_finite_debug), -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, "get_singleton", VALUEFUNC(_wrap_SkeletonManager_get_singleton), -1);
  rb_define_singleton_method(SwigClassSkeletonManager.klass, "get_singleton_ptr", VALUEFUNC(_wrap_SkeletonManager_get_singleton_ptr), -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, "export_skeleton", VALUEFUNC(_wrap_SkeletonSerializer_export_skeleton), -1);
  rb_define_method(SwigClassSkeletonSerializer.klass, "import_skeleton", VALUEFUNC(_wrap_SkeletonSerializer_import_skeleton), -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, "get_name", VALUEFUNC(_wrap_StaticGeometry_get_name), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "add_entity", VALUEFUNC(_wrap_StaticGeometry_add_entity), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "add_scene_node", VALUEFUNC(_wrap_StaticGeometry_add_scene_node), -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, "set_rendering_distance", VALUEFUNC(_wrap_StaticGeometry_set_rendering_distance), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "get_rendering_distance", VALUEFUNC(_wrap_StaticGeometry_get_rendering_distance), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "get_squared_rendering_distance", VALUEFUNC(_wrap_StaticGeometry_get_squared_rendering_distance), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "set_visible", VALUEFUNC(_wrap_StaticGeometry_set_visible), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "is_visible", VALUEFUNC(_wrap_StaticGeometry_is_visible), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "set_cast_shadows", VALUEFUNC(_wrap_StaticGeometry_set_cast_shadows), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "get_cast_shadows", VALUEFUNC(_wrap_StaticGeometry_get_cast_shadows), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "set_region_dimensions", VALUEFUNC(_wrap_StaticGeometry_set_region_dimensions), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "get_region_dimensions", VALUEFUNC(_wrap_StaticGeometry_get_region_dimensions), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "set_origin", VALUEFUNC(_wrap_StaticGeometry_set_origin), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "get_origin", VALUEFUNC(_wrap_StaticGeometry_get_origin), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "set_visibility_flags", VALUEFUNC(_wrap_StaticGeometry_set_visibility_flags), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "get_visibility_flags", VALUEFUNC(_wrap_StaticGeometry_get_visibility_flags), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "set_render_queue_group", VALUEFUNC(_wrap_StaticGeometry_set_render_queue_group), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "get_render_queue_group", VALUEFUNC(_wrap_StaticGeometry_get_render_queue_group), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "visit_renderables", VALUEFUNC(_wrap_StaticGeometry_visit_renderables), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "get_region_iterator", VALUEFUNC(_wrap_StaticGeometry_get_region_iterator), -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, "get_endian", VALUEFUNC(_wrap_StreamSerialiser_get_endian), -1);
  rb_define_singleton_method(SwigClassStreamSerialiser.klass, "make_identifier", VALUEFUNC(_wrap_StreamSerialiser_make_identifier), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "get_current_chunk_depth", VALUEFUNC(_wrap_StreamSerialiser_get_current_chunk_depth), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "get_current_chunk_id", VALUEFUNC(_wrap_StreamSerialiser_get_current_chunk_id), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "get_offset_from_chunk_start", VALUEFUNC(_wrap_StreamSerialiser_get_offset_from_chunk_start), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "read_chunk_begin", VALUEFUNC(_wrap_StreamSerialiser_read_chunk_begin), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "undo_read_chunk", VALUEFUNC(_wrap_StreamSerialiser_undo_read_chunk), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "peek_next_chunk_id", VALUEFUNC(_wrap_StreamSerialiser_peek_next_chunk_id), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "read_chunk_end", VALUEFUNC(_wrap_StreamSerialiser_read_chunk_end), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "is_end_of_chunk", VALUEFUNC(_wrap_StreamSerialiser_is_end_of_chunk), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "eof", VALUEFUNC(_wrap_StreamSerialiser_eof), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "get_current_chunk", VALUEFUNC(_wrap_StreamSerialiser_get_current_chunk), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "write_chunk_begin", VALUEFUNC(_wrap_StreamSerialiser_write_chunk_begin), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "write_chunk_end", VALUEFUNC(_wrap_StreamSerialiser_write_chunk_end), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "write_data", VALUEFUNC(_wrap_StreamSerialiser_write_data), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "write", VALUEFUNC(_wrap_StreamSerialiser_write), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "read_data", VALUEFUNC(_wrap_StreamSerialiser_read_data), -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, "get_material_name", VALUEFUNC(_wrap_SubEntity_get_material_name), -1);
  rb_define_method(SwigClassSubEntity.klass, "set_material_name", VALUEFUNC(_wrap_SubEntity_set_material_name), -1);
  rb_define_method(SwigClassSubEntity.klass, "set_material", VALUEFUNC(_wrap_SubEntity_set_material), -1);
  rb_define_method(SwigClassSubEntity.klass, "set_visible", VALUEFUNC(_wrap_SubEntity_set_visible), -1);
  rb_define_method(SwigClassSubEntity.klass, "is_visible", VALUEFUNC(_wrap_SubEntity_is_visible), -1);
  rb_define_method(SwigClassSubEntity.klass, "set_render_queue_group", VALUEFUNC(_wrap_SubEntity_set_render_queue_group), -1);
  rb_define_method(SwigClassSubEntity.klass, "set_render_queue_group_and_priority", VALUEFUNC(_wrap_SubEntity_set_render_queue_group_and_priority), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_render_queue_group", VALUEFUNC(_wrap_SubEntity_get_render_queue_group), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_render_queue_priority", VALUEFUNC(_wrap_SubEntity_get_render_queue_priority), -1);
  rb_define_method(SwigClassSubEntity.klass, "is_render_queue_group_set", VALUEFUNC(_wrap_SubEntity_is_render_queue_group_set), -1);
  rb_define_method(SwigClassSubEntity.klass, "is_render_queue_priority_set", VALUEFUNC(_wrap_SubEntity_is_render_queue_priority_set), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_sub_mesh", VALUEFUNC(_wrap_SubEntity_get_sub_mesh), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_parent", VALUEFUNC(_wrap_SubEntity_get_parent), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_material", VALUEFUNC(_wrap_SubEntity_get_material), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_technique", VALUEFUNC(_wrap_SubEntity_get_technique), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_render_operation", VALUEFUNC(_wrap_SubEntity_get_render_operation), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_world_transforms", VALUEFUNC(_wrap_SubEntity_get_world_transforms), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_num_world_transforms", VALUEFUNC(_wrap_SubEntity_get_num_world_transforms), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_squared_view_depth", VALUEFUNC(_wrap_SubEntity_get_squared_view_depth), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_lights", VALUEFUNC(_wrap_SubEntity_get_lights), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_casts_shadows", VALUEFUNC(_wrap_SubEntity_get_casts_shadows), -1);
  rb_define_method(SwigClassSubEntity.klass, "_get_skel_anim_vertex_data", VALUEFUNC(_wrap_SubEntity__get_skel_anim_vertex_data), -1);
  rb_define_method(SwigClassSubEntity.klass, "_get_software_vertex_anim_vertex_data", VALUEFUNC(_wrap_SubEntity__get_software_vertex_anim_vertex_data), -1);
  rb_define_method(SwigClassSubEntity.klass, "_get_hardware_vertex_anim_vertex_data", VALUEFUNC(_wrap_SubEntity__get_hardware_vertex_anim_vertex_data), -1);
  rb_define_method(SwigClassSubEntity.klass, "_get_skel_anim_temp_buffer_info", VALUEFUNC(_wrap_SubEntity__get_skel_anim_temp_buffer_info), -1);
  rb_define_method(SwigClassSubEntity.klass, "_get_vertex_anim_temp_buffer_info", VALUEFUNC(_wrap_SubEntity__get_vertex_anim_temp_buffer_info), -1);
  rb_define_method(SwigClassSubEntity.klass, "get_vertex_data_for_binding", VALUEFUNC(_wrap_SubEntity_get_vertex_data_for_binding), -1);
  rb_define_method(SwigClassSubEntity.klass, "_mark_buffers_unused_for_animation", VALUEFUNC(_wrap_SubEntity__mark_buffers_unused_for_animation), -1);
  rb_define_method(SwigClassSubEntity.klass, "_mark_buffers_used_for_animation", VALUEFUNC(_wrap_SubEntity__mark_buffers_used_for_animation), -1);
  rb_define_method(SwigClassSubEntity.klass, "_get_buffers_marked_for_animation", VALUEFUNC(_wrap_SubEntity__get_buffers_marked_for_animation), -1);
  rb_define_method(SwigClassSubEntity.klass, "_restore_buffers_for_unused_animation", VALUEFUNC(_wrap_SubEntity__restore_buffers_for_unused_animation), -1);
  rb_define_method(SwigClassSubEntity.klass, "_update_custom_gpu_parameter", VALUEFUNC(_wrap_SubEntity__update_custom_gpu_parameter), -1);
  rb_define_method(SwigClassSubEntity.klass, "_invalidate_camera_cache", VALUEFUNC(_wrap_SubEntity__invalidate_camera_cache), -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, "set_material_name", VALUEFUNC(_wrap_SubMesh_set_material_name), -1);
  rb_define_method(SwigClassSubMesh.klass, "get_material_name", VALUEFUNC(_wrap_SubMesh_get_material_name), -1);
  rb_define_method(SwigClassSubMesh.klass, "is_mat_initialised", VALUEFUNC(_wrap_SubMesh_is_mat_initialised), -1);
  rb_define_method(SwigClassSubMesh.klass, "_get_render_operation", VALUEFUNC(_wrap_SubMesh__get_render_operation), -1);
  rb_define_method(SwigClassSubMesh.klass, "add_bone_assignment", VALUEFUNC(_wrap_SubMesh_add_bone_assignment), -1);
  rb_define_method(SwigClassSubMesh.klass, "clear_bone_assignments", VALUEFUNC(_wrap_SubMesh_clear_bone_assignments), -1);
  rb_define_method(SwigClassSubMesh.klass, "get_bone_assignment_iterator", VALUEFUNC(_wrap_SubMesh_get_bone_assignment_iterator), -1);
  rb_define_method(SwigClassSubMesh.klass, "get_bone_assignments", VALUEFUNC(_wrap_SubMesh_get_bone_assignments), -1);
  rb_define_method(SwigClassSubMesh.klass, "_compile_bone_assignments", VALUEFUNC(_wrap_SubMesh__compile_bone_assignments), -1);
  rb_define_method(SwigClassSubMesh.klass, "get_alias_texture_iterator", VALUEFUNC(_wrap_SubMesh_get_alias_texture_iterator), -1);
  rb_define_method(SwigClassSubMesh.klass, "add_texture_alias", VALUEFUNC(_wrap_SubMesh_add_texture_alias), -1);
  rb_define_method(SwigClassSubMesh.klass, "remove_texture_alias", VALUEFUNC(_wrap_SubMesh_remove_texture_alias), -1);
  rb_define_method(SwigClassSubMesh.klass, "remove_all_texture_aliases", VALUEFUNC(_wrap_SubMesh_remove_all_texture_aliases), -1);
  rb_define_method(SwigClassSubMesh.klass, "has_texture_aliases", VALUEFUNC(_wrap_SubMesh_has_texture_aliases), -1);
  rb_define_method(SwigClassSubMesh.klass, "get_texture_alias_count", VALUEFUNC(_wrap_SubMesh_get_texture_alias_count), -1);
  rb_define_method(SwigClassSubMesh.klass, "update_material_using_texture_aliases", VALUEFUNC(_wrap_SubMesh_update_material_using_texture_aliases), -1);
  rb_define_method(SwigClassSubMesh.klass, "get_vertex_animation_type", VALUEFUNC(_wrap_SubMesh_get_vertex_animation_type), -1);
  rb_define_method(SwigClassSubMesh.klass, "get_vertex_animation_includes_normals", VALUEFUNC(_wrap_SubMesh_get_vertex_animation_includes_normals), -1);
  rb_define_method(SwigClassSubMesh.klass, "generate_extremes", VALUEFUNC(_wrap_SubMesh_generate_extremes), -1);
  rb_define_method(SwigClassSubMesh.klass, "is_build_edges_enabled", VALUEFUNC(_wrap_SubMesh_is_build_edges_enabled), -1);
  rb_define_method(SwigClassSubMesh.klass, "set_build_edges_enabled", VALUEFUNC(_wrap_SubMesh_set_build_edges_enabled), -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, "get_parent_entity", VALUEFUNC(_wrap_TagPoint_get_parent_entity), -1);
  rb_define_method(SwigClassTagPoint.klass, "get_child_object", VALUEFUNC(_wrap_TagPoint_get_child_object), -1);
  rb_define_method(SwigClassTagPoint.klass, "set_parent_entity", VALUEFUNC(_wrap_TagPoint_set_parent_entity), -1);
  rb_define_method(SwigClassTagPoint.klass, "set_child_object", VALUEFUNC(_wrap_TagPoint_set_child_object), -1);
  rb_define_method(SwigClassTagPoint.klass, "set_inherit_parent_entity_orientation", VALUEFUNC(_wrap_TagPoint_set_inherit_parent_entity_orientation), -1);
  rb_define_method(SwigClassTagPoint.klass, "get_inherit_parent_entity_orientation", VALUEFUNC(_wrap_TagPoint_get_inherit_parent_entity_orientation), -1);
  rb_define_method(SwigClassTagPoint.klass, "set_inherit_parent_entity_scale", VALUEFUNC(_wrap_TagPoint_set_inherit_parent_entity_scale), -1);
  rb_define_method(SwigClassTagPoint.klass, "get_inherit_parent_entity_scale", VALUEFUNC(_wrap_TagPoint_get_inherit_parent_entity_scale), -1);
  rb_define_method(SwigClassTagPoint.klass, "get_parent_entity_transform", VALUEFUNC(_wrap_TagPoint_get_parent_entity_transform), -1);
  rb_define_method(SwigClassTagPoint.klass, "_get_full_local_transform", VALUEFUNC(_wrap_TagPoint__get_full_local_transform), -1);
  rb_define_method(SwigClassTagPoint.klass, "need_update", VALUEFUNC(_wrap_TagPoint_need_update), -1);
  rb_define_method(SwigClassTagPoint.klass, "update_from_parent_impl", VALUEFUNC(_wrap_TagPoint_update_from_parent_impl), -1);
  rb_define_method(SwigClassTagPoint.klass, "get_lights", VALUEFUNC(_wrap_TagPoint_get_lights), -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, "set_vertex_data", VALUEFUNC(_wrap_TangentSpaceCalc_set_vertex_data), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "add_index_data", VALUEFUNC(_wrap_TangentSpaceCalc_add_index_data), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "set_store_parity_in_w", VALUEFUNC(_wrap_TangentSpaceCalc_set_store_parity_in_w), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "get_store_parity_in_w", VALUEFUNC(_wrap_TangentSpaceCalc_get_store_parity_in_w), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "set_split_mirrored", VALUEFUNC(_wrap_TangentSpaceCalc_set_split_mirrored), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "get_split_mirrored", VALUEFUNC(_wrap_TangentSpaceCalc_get_split_mirrored), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "set_split_rotated", VALUEFUNC(_wrap_TangentSpaceCalc_set_split_rotated), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "get_split_rotated", VALUEFUNC(_wrap_TangentSpaceCalc_get_split_rotated), -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, "add_delegate_program", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_add_delegate_program), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "clear_delegate_programs", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_clear_delegate_programs), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "_get_delegate", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram__get_delegate), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "get_language", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_get_language), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "create_parameters", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_create_parameters), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "_get_binding_delegate", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram__get_binding_delegate), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "is_supported", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_is_supported), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "is_skeletal_animation_included", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_is_skeletal_animation_included), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "is_morph_animation_included", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_is_morph_animation_included), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "is_pose_animation_included", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_is_pose_animation_included), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "is_vertex_texture_fetch_required", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_is_vertex_texture_fetch_required), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "get_default_parameters", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_get_default_parameters), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "has_default_parameters", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_has_default_parameters), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "get_pass_surface_and_light_states", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_get_pass_surface_and_light_states), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "get_pass_fog_states", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_get_pass_fog_states), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "get_pass_transform_states", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_get_pass_transform_states), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "has_compile_error", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_has_compile_error), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "reset_compile_error", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_reset_compile_error), -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, "is_reloadable", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_is_reloadable), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "is_loaded", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_is_loaded), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "is_loading", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_is_loading), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "get_loading_state", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_get_loading_state), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "unload", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_unload), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "get_size", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_get_size), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "touch", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_touch), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "is_background_loaded", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_is_background_loaded), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "set_background_loaded", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_set_background_loaded), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "escalate_loading", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_escalate_loading), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "add_listener", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_add_listener), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "remove_listener", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_remove_listener), -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, "window_moved", VALUEFUNC(_wrap_WindowEventListener_window_moved), -1);
  rb_define_method(SwigClassWindowEventListener.klass, "window_resized", VALUEFUNC(_wrap_WindowEventListener_window_resized), -1);
  rb_define_method(SwigClassWindowEventListener.klass, "window_closing", VALUEFUNC(_wrap_WindowEventListener_window_closing), -1);
  rb_define_method(SwigClassWindowEventListener.klass, "window_closed", VALUEFUNC(_wrap_WindowEventListener_window_closed), -1);
  rb_define_method(SwigClassWindowEventListener.klass, "window_focus_change", VALUEFUNC(_wrap_WindowEventListener_window_focus_change), -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, "message_pump", VALUEFUNC(_wrap_WindowEventUtilities_message_pump), -1);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "add_window_event_listener", VALUEFUNC(_wrap_WindowEventUtilities_add_window_event_listener), -1);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "remove_window_event_listener", VALUEFUNC(_wrap_WindowEventUtilities_remove_window_event_listener), -1);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "_add_render_window", VALUEFUNC(_wrap_WindowEventUtilities__add_render_window), -1);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "_remove_render_window", VALUEFUNC(_wrap_WindowEventUtilities__remove_render_window), -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, "setup_bounding_box", VALUEFUNC(_wrap_WireBoundingBox_setup_bounding_box), -1);
  rb_define_method(SwigClassWireBoundingBox.klass, "get_squared_view_depth", VALUEFUNC(_wrap_WireBoundingBox_get_squared_view_depth), -1);
  rb_define_method(SwigClassWireBoundingBox.klass, "get_bounding_radius", VALUEFUNC(_wrap_WireBoundingBox_get_bounding_radius), -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, "is_case_sensitive", VALUEFUNC(_wrap_ZipArchive_is_case_sensitive), -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, "list_file_info", VALUEFUNC(_wrap_ZipArchive_list_file_info), -1);
  rb_define_method(SwigClassZipArchive.klass, "find", VALUEFUNC(_wrap_ZipArchive_find), -1);
  rb_define_method(SwigClassZipArchive.klass, "find_file_info", VALUEFUNC(_wrap_ZipArchive_find_file_info), -1);
  rb_define_method(SwigClassZipArchive.klass, "exists", VALUEFUNC(_wrap_ZipArchive_exists), -1);
  rb_define_method(SwigClassZipArchive.klass, "get_modified_time", VALUEFUNC(_wrap_ZipArchive_get_modified_time), -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, "get_type", VALUEFUNC(_wrap_EmbeddedZipArchiveFactory_get_type), -1);
  rb_define_method(SwigClassEmbeddedZipArchiveFactory.klass, "create_instance", VALUEFUNC(_wrap_EmbeddedZipArchiveFactory_create_instance), -1);
  rb_define_singleton_method(SwigClassEmbeddedZipArchiveFactory.klass, "add_embbedded_file", VALUEFUNC(_wrap_EmbeddedZipArchiveFactory_add_embbedded_file), -1);
  rb_define_singleton_method(SwigClassEmbeddedZipArchiveFactory.klass, "remove_embbedded_file", VALUEFUNC(_wrap_EmbeddedZipArchiveFactory_remove_embbedded_file), -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, "get_name", VALUEFUNC(_wrap_PageStrategy_get_name), -1);
  rb_define_method(SwigClassPageStrategy.klass, "get_manager", VALUEFUNC(_wrap_PageStrategy_get_manager), -1);
  rb_define_method(SwigClassPageStrategy.klass, "frame_start", VALUEFUNC(_wrap_PageStrategy_frame_start), -1);
  rb_define_method(SwigClassPageStrategy.klass, "frame_end", VALUEFUNC(_wrap_PageStrategy_frame_end), -1);
  rb_define_method(SwigClassPageStrategy.klass, "notify_camera", VALUEFUNC(_wrap_PageStrategy_notify_camera), -1);
  rb_define_method(SwigClassPageStrategy.klass, "create_data", VALUEFUNC(_wrap_PageStrategy_create_data), -1);
  rb_define_method(SwigClassPageStrategy.klass, "destroy_data", VALUEFUNC(_wrap_PageStrategy_destroy_data), -1);
  rb_define_method(SwigClassPageStrategy.klass, "update_debug_display", VALUEFUNC(_wrap_PageStrategy_update_debug_display), -1);
  rb_define_method(SwigClassPageStrategy.klass, "get_page_id", VALUEFUNC(_wrap_PageStrategy_get_page_id), -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, "set_mode", VALUEFUNC(_wrap_Grid2DPageStrategyData_set_mode), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_mode", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_mode), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "set_origin", VALUEFUNC(_wrap_Grid2DPageStrategyData_set_origin), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_origin", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_origin), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "set_cell_size", VALUEFUNC(_wrap_Grid2DPageStrategyData_set_cell_size), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_cell_size", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_cell_size), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "set_load_radius", VALUEFUNC(_wrap_Grid2DPageStrategyData_set_load_radius), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_load_radius", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_load_radius), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "set_hold_radius", VALUEFUNC(_wrap_Grid2DPageStrategyData_set_hold_radius), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_hold_radius", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_hold_radius), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_load_radius_in_cells", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_load_radius_in_cells), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_hold_radius_in_cells", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_hold_radius_in_cells), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "set_cell_range", VALUEFUNC(_wrap_Grid2DPageStrategyData_set_cell_range), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "set_cell_range_min_x", VALUEFUNC(_wrap_Grid2DPageStrategyData_set_cell_range_min_x), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "set_cell_range_min_y", VALUEFUNC(_wrap_Grid2DPageStrategyData_set_cell_range_min_y), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "set_cell_range_max_x", VALUEFUNC(_wrap_Grid2DPageStrategyData_set_cell_range_max_x), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "set_cell_range_max_y", VALUEFUNC(_wrap_Grid2DPageStrategyData_set_cell_range_max_y), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_cell_range_min_x", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_cell_range_min_x), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_cell_range_min_y", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_cell_range_min_y), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_cell_range_max_x", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_cell_range_max_x), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_cell_range_max_y", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_cell_range_max_y), -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, "convert_world_to_grid_space", VALUEFUNC(_wrap_Grid2DPageStrategyData_convert_world_to_grid_space), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "convert_grid_to_world_space", VALUEFUNC(_wrap_Grid2DPageStrategyData_convert_grid_to_world_space), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_mid_point_grid_space", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_mid_point_grid_space), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_bottom_left_grid_space", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_bottom_left_grid_space), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "get_corners_grid_space", VALUEFUNC(_wrap_Grid2DPageStrategyData_get_corners_grid_space), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "determine_grid_location", VALUEFUNC(_wrap_Grid2DPageStrategyData_determine_grid_location), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "calculate_page_id", VALUEFUNC(_wrap_Grid2DPageStrategyData_calculate_page_id), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "calculate_cell", VALUEFUNC(_wrap_Grid2DPageStrategyData_calculate_cell), -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, "notify_camera", VALUEFUNC(_wrap_Grid2DPageStrategy_notify_camera), -1);
  rb_define_method(SwigClassGrid2DPageStrategy.klass, "create_data", VALUEFUNC(_wrap_Grid2DPageStrategy_create_data), -1);
  rb_define_method(SwigClassGrid2DPageStrategy.klass, "destroy_data", VALUEFUNC(_wrap_Grid2DPageStrategy_destroy_data), -1);
  rb_define_method(SwigClassGrid2DPageStrategy.klass, "update_debug_display", VALUEFUNC(_wrap_Grid2DPageStrategy_update_debug_display), -1);
  rb_define_method(SwigClassGrid2DPageStrategy.klass, "get_page_id", VALUEFUNC(_wrap_Grid2DPageStrategy_get_page_id), -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, "set_origin", VALUEFUNC(_wrap_Grid3DPageStrategyData_set_origin), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "get_origin", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_origin), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "set_cell_size", VALUEFUNC(_wrap_Grid3DPageStrategyData_set_cell_size), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "get_cell_size", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_cell_size), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "set_load_radius", VALUEFUNC(_wrap_Grid3DPageStrategyData_set_load_radius), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "get_load_radius", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_load_radius), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "set_hold_radius", VALUEFUNC(_wrap_Grid3DPageStrategyData_set_hold_radius), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "get_hold_radius", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_hold_radius), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "set_cell_range", VALUEFUNC(_wrap_Grid3DPageStrategyData_set_cell_range), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "set_cell_range_min_x", VALUEFUNC(_wrap_Grid3DPageStrategyData_set_cell_range_min_x), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "set_cell_range_min_y", VALUEFUNC(_wrap_Grid3DPageStrategyData_set_cell_range_min_y), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "set_cell_range_min_z", VALUEFUNC(_wrap_Grid3DPageStrategyData_set_cell_range_min_z), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "set_cell_range_max_x", VALUEFUNC(_wrap_Grid3DPageStrategyData_set_cell_range_max_x), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "set_cell_range_max_y", VALUEFUNC(_wrap_Grid3DPageStrategyData_set_cell_range_max_y), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "set_cell_range_max_z", VALUEFUNC(_wrap_Grid3DPageStrategyData_set_cell_range_max_z), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "get_cell_range_min_x", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_cell_range_min_x), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "get_cell_range_min_y", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_cell_range_min_y), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "get_cell_range_min_z", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_cell_range_min_z), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "get_cell_range_max_x", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_cell_range_max_x), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "get_cell_range_max_y", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_cell_range_max_y), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "get_cell_range_max_z", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_cell_range_max_z), -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, "get_mid_point_grid_space", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_mid_point_grid_space), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "get_bottom_left_grid_space", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_bottom_left_grid_space), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "get_corners_grid_space", VALUEFUNC(_wrap_Grid3DPageStrategyData_get_corners_grid_space), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "determine_grid_location", VALUEFUNC(_wrap_Grid3DPageStrategyData_determine_grid_location), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "calculate_page_id", VALUEFUNC(_wrap_Grid3DPageStrategyData_calculate_page_id), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "calculate_cell", VALUEFUNC(_wrap_Grid3DPageStrategyData_calculate_cell), -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, "notify_camera", VALUEFUNC(_wrap_Grid3DPageStrategy_notify_camera), -1);
  rb_define_method(SwigClassGrid3DPageStrategy.klass, "create_data", VALUEFUNC(_wrap_Grid3DPageStrategy_create_data), -1);
  rb_define_method(SwigClassGrid3DPageStrategy.klass, "destroy_data", VALUEFUNC(_wrap_Grid3DPageStrategy_destroy_data), -1);
  rb_define_method(SwigClassGrid3DPageStrategy.klass, "update_debug_display", VALUEFUNC(_wrap_Grid3DPageStrategy_update_debug_display), -1);
  rb_define_method(SwigClassGrid3DPageStrategy.klass, "get_page_id", VALUEFUNC(_wrap_Grid3DPageStrategy_get_page_id), -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, "get_manager", VALUEFUNC(_wrap_Page_get_manager), -1);
  rb_define_method(SwigClassPage.klass, "get_scene_manager", VALUEFUNC(_wrap_Page_get_scene_manager), -1);
  rb_define_method(SwigClassPage.klass, "is_deferred_process_in_progress", VALUEFUNC(_wrap_Page_is_deferred_process_in_progress), -1);
  rb_define_method(SwigClassPage.klass, "get_id", VALUEFUNC(_wrap_Page_get_id), -1);
  rb_define_method(SwigClassPage.klass, "get_parent_section", VALUEFUNC(_wrap_Page_get_parent_section), -1);
  rb_define_method(SwigClassPage.klass, "get_frame_last_held", VALUEFUNC(_wrap_Page_get_frame_last_held), -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, "is_held", VALUEFUNC(_wrap_Page_is_held), -1);
  rb_define_method(SwigClassPage.klass, "save", VALUEFUNC(_wrap_Page_save), -1);
  rb_define_method(SwigClassPage.klass, "frame_start", VALUEFUNC(_wrap_Page_frame_start), -1);
  rb_define_method(SwigClassPage.klass, "frame_end", VALUEFUNC(_wrap_Page_frame_end), -1);
  rb_define_method(SwigClassPage.klass, "notify_camera", VALUEFUNC(_wrap_Page_notify_camera), -1);
  rb_define_method(SwigClassPage.klass, "create_content_collection", VALUEFUNC(_wrap_Page_create_content_collection), -1);
  rb_define_method(SwigClassPage.klass, "destroy_content_collection", VALUEFUNC(_wrap_Page_destroy_content_collection), -1);
  rb_define_method(SwigClassPage.klass, "destroy_all_content_collections", VALUEFUNC(_wrap_Page_destroy_all_content_collections), -1);
  rb_define_method(SwigClassPage.klass, "get_content_collection_count", VALUEFUNC(_wrap_Page_get_content_collection_count), -1);
  rb_define_method(SwigClassPage.klass, "get_content_collection", VALUEFUNC(_wrap_Page_get_content_collection), -1);
  rb_define_method(SwigClassPage.klass, "get_content_collection_list", VALUEFUNC(_wrap_Page_get_content_collection_list), -1);
  rb_define_method(SwigClassPage.klass, "can_handle_request", VALUEFUNC(_wrap_Page_can_handle_request), -1);
  rb_define_method(SwigClassPage.klass, "handle_request", VALUEFUNC(_wrap_Page_handle_request), -1);
  rb_define_method(SwigClassPage.klass, "can_handle_response", VALUEFUNC(_wrap_Page_can_handle_response), -1);
  rb_define_method(SwigClassPage.klass, "handle_response", VALUEFUNC(_wrap_Page_handle_response), -1);
  rb_define_method(SwigClassPage.klass, "_notify_modified", VALUEFUNC(_wrap_Page__notify_modified), -1);
  rb_define_method(SwigClassPage.klass, "is_modified", VALUEFUNC(_wrap_Page_is_modified), -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, "get_manager", VALUEFUNC(_wrap_PageContent_get_manager), -1);
  rb_define_method(SwigClassPageContent.klass, "get_scene_manager", VALUEFUNC(_wrap_PageContent_get_scene_manager), -1);
  rb_define_method(SwigClassPageContent.klass, "_notify_attached", VALUEFUNC(_wrap_PageContent__notify_attached), -1);
  rb_define_method(SwigClassPageContent.klass, "get_type", VALUEFUNC(_wrap_PageContent_get_type), -1);
  rb_define_method(SwigClassPageContent.klass, "save", VALUEFUNC(_wrap_PageContent_save), -1);
  rb_define_method(SwigClassPageContent.klass, "frame_start", VALUEFUNC(_wrap_PageContent_frame_start), -1);
  rb_define_method(SwigClassPageContent.klass, "frame_end", VALUEFUNC(_wrap_PageContent_frame_end), -1);
  rb_define_method(SwigClassPageContent.klass, "notify_camera", VALUEFUNC(_wrap_PageContent_notify_camera), -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, "get_manager", VALUEFUNC(_wrap_PageContentCollection_get_manager), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "get_parent_page", VALUEFUNC(_wrap_PageContentCollection_get_parent_page), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "get_scene_manager", VALUEFUNC(_wrap_PageContentCollection_get_scene_manager), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "get_type", VALUEFUNC(_wrap_PageContentCollection_get_type), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "_notify_attached", VALUEFUNC(_wrap_PageContentCollection__notify_attached), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "save", VALUEFUNC(_wrap_PageContentCollection_save), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "frame_start", VALUEFUNC(_wrap_PageContentCollection_frame_start), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "frame_end", VALUEFUNC(_wrap_PageContentCollection_frame_end), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "notify_camera", VALUEFUNC(_wrap_PageContentCollection_notify_camera), -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, "get_name", VALUEFUNC(_wrap_PageContentCollectionFactory_get_name), -1);
  rb_define_method(SwigClassPageContentCollectionFactory.klass, "create_instance", VALUEFUNC(_wrap_PageContentCollectionFactory_create_instance), -1);
  rb_define_method(SwigClassPageContentCollectionFactory.klass, "destroy_instance", VALUEFUNC(_wrap_PageContentCollectionFactory_destroy_instance), -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, "get_name", VALUEFUNC(_wrap_PageContentFactory_get_name), -1);
  rb_define_method(SwigClassPageContentFactory.klass, "create_instance", VALUEFUNC(_wrap_PageContentFactory_create_instance), -1);
  rb_define_method(SwigClassPageContentFactory.klass, "destroy_instance", VALUEFUNC(_wrap_PageContentFactory_destroy_instance), -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, "prepare_procedural_page", VALUEFUNC(_wrap_PageProvider_prepare_procedural_page), -1);
  rb_define_method(SwigClassPageProvider.klass, "load_procedural_page", VALUEFUNC(_wrap_PageProvider_load_procedural_page), -1);
  rb_define_method(SwigClassPageProvider.klass, "unload_procedural_page", VALUEFUNC(_wrap_PageProvider_unload_procedural_page), -1);
  rb_define_method(SwigClassPageProvider.klass, "unprepare_procedural_page", VALUEFUNC(_wrap_PageProvider_unprepare_procedural_page), -1);
  rb_define_method(SwigClassPageProvider.klass, "read_world_stream", VALUEFUNC(_wrap_PageProvider_read_world_stream), -1);
  rb_define_method(SwigClassPageProvider.klass, "write_world_stream", VALUEFUNC(_wrap_PageProvider_write_world_stream), -1);
  rb_define_method(SwigClassPageProvider.klass, "read_page_stream", VALUEFUNC(_wrap_PageProvider_read_page_stream), -1);
  rb_define_method(SwigClassPageProvider.klass, "write_page_stream", VALUEFUNC(_wrap_PageProvider_write_page_stream), -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, "create_world", VALUEFUNC(_wrap_PageManager_create_world), -1);
  rb_define_method(SwigClassPageManager.klass, "destroy_world", VALUEFUNC(_wrap_PageManager_destroy_world), -1);
  rb_define_method(SwigClassPageManager.klass, "load_world", VALUEFUNC(_wrap_PageManager_load_world), -1);
  rb_define_method(SwigClassPageManager.klass, "save_world", VALUEFUNC(_wrap_PageManager_save_world), -1);
  rb_define_method(SwigClassPageManager.klass, "get_world", VALUEFUNC(_wrap_PageManager_get_world), -1);
  rb_define_method(SwigClassPageManager.klass, "get_worlds", VALUEFUNC(_wrap_PageManager_get_worlds), -1);
  rb_define_method(SwigClassPageManager.klass, "add_strategy", VALUEFUNC(_wrap_PageManager_add_strategy), -1);
  rb_define_method(SwigClassPageManager.klass, "remove_strategy", VALUEFUNC(_wrap_PageManager_remove_strategy), -1);
  rb_define_method(SwigClassPageManager.klass, "get_strategy", VALUEFUNC(_wrap_PageManager_get_strategy), -1);
  rb_define_method(SwigClassPageManager.klass, "get_strategies", VALUEFUNC(_wrap_PageManager_get_strategies), -1);
  rb_define_method(SwigClassPageManager.klass, "add_content_collection_factory", VALUEFUNC(_wrap_PageManager_add_content_collection_factory), -1);
  rb_define_method(SwigClassPageManager.klass, "remove_content_collection_factory", VALUEFUNC(_wrap_PageManager_remove_content_collection_factory), -1);
  rb_define_method(SwigClassPageManager.klass, "get_content_collection_factory", VALUEFUNC(_wrap_PageManager_get_content_collection_factory), -1);
  rb_define_method(SwigClassPageManager.klass, "create_content_collection", VALUEFUNC(_wrap_PageManager_create_content_collection), -1);
  rb_define_method(SwigClassPageManager.klass, "destroy_content_collection", VALUEFUNC(_wrap_PageManager_destroy_content_collection), -1);
  rb_define_method(SwigClassPageManager.klass, "get_content_collection_factories", VALUEFUNC(_wrap_PageManager_get_content_collection_factories), -1);
  rb_define_method(SwigClassPageManager.klass, "add_content_factory", VALUEFUNC(_wrap_PageManager_add_content_factory), -1);
  rb_define_method(SwigClassPageManager.klass, "remove_content_factory", VALUEFUNC(_wrap_PageManager_remove_content_factory), -1);
  rb_define_method(SwigClassPageManager.klass, "get_content_factory", VALUEFUNC(_wrap_PageManager_get_content_factory), -1);
  rb_define_method(SwigClassPageManager.klass, "get_content_factories", VALUEFUNC(_wrap_PageManager_get_content_factories), -1);
  rb_define_method(SwigClassPageManager.klass, "create_content", VALUEFUNC(_wrap_PageManager_create_content), -1);
  rb_define_method(SwigClassPageManager.klass, "destroy_content", VALUEFUNC(_wrap_PageManager_destroy_content), -1);
  rb_define_method(SwigClassPageManager.klass, "add_world_section_factory", VALUEFUNC(_wrap_PageManager_add_world_section_factory), -1);
  rb_define_method(SwigClassPageManager.klass, "remove_world_section_factory", VALUEFUNC(_wrap_PageManager_remove_world_section_factory), -1);
  rb_define_method(SwigClassPageManager.klass, "get_world_section_factory", VALUEFUNC(_wrap_PageManager_get_world_section_factory), -1);
  rb_define_method(SwigClassPageManager.klass, "create_world_section", VALUEFUNC(_wrap_PageManager_create_world_section), -1);
  rb_define_method(SwigClassPageManager.klass, "destroy_world_section", VALUEFUNC(_wrap_PageManager_destroy_world_section), -1);
  rb_define_method(SwigClassPageManager.klass, "get_world_section_factories", VALUEFUNC(_wrap_PageManager_get_world_section_factories), -1);
  rb_define_method(SwigClassPageManager.klass, "set_page_provider", VALUEFUNC(_wrap_PageManager_set_page_provider), -1);
  rb_define_method(SwigClassPageManager.klass, "get_page_provider", VALUEFUNC(_wrap_PageManager_get_page_provider), -1);
  rb_define_method(SwigClassPageManager.klass, "_prepare_procedural_page", VALUEFUNC(_wrap_PageManager__prepare_procedural_page), -1);
  rb_define_method(SwigClassPageManager.klass, "_load_procedural_page", VALUEFUNC(_wrap_PageManager__load_procedural_page), -1);
  rb_define_method(SwigClassPageManager.klass, "_unload_procedural_page", VALUEFUNC(_wrap_PageManager__unload_procedural_page), -1);
  rb_define_method(SwigClassPageManager.klass, "_unprepare_procedural_page", VALUEFUNC(_wrap_PageManager__unprepare_procedural_page), -1);
  rb_define_method(SwigClassPageManager.klass, "_read_page_stream", VALUEFUNC(_wrap_PageManager__read_page_stream), -1);
  rb_define_method(SwigClassPageManager.klass, "_write_page_stream", VALUEFUNC(_wrap_PageManager__write_page_stream), -1);
  rb_define_method(SwigClassPageManager.klass, "_read_world_stream", VALUEFUNC(_wrap_PageManager__read_world_stream), -1);
  rb_define_method(SwigClassPageManager.klass, "_write_world_stream", VALUEFUNC(_wrap_PageManager__write_world_stream), -1);
  rb_define_method(SwigClassPageManager.klass, "get_page_resource_group", VALUEFUNC(_wrap_PageManager_get_page_resource_group), -1);
  rb_define_method(SwigClassPageManager.klass, "set_page_resource_group", VALUEFUNC(_wrap_PageManager_set_page_resource_group), -1);
  rb_define_method(SwigClassPageManager.klass, "add_camera", VALUEFUNC(_wrap_PageManager_add_camera), -1);
  rb_define_method(SwigClassPageManager.klass, "remove_camera", VALUEFUNC(_wrap_PageManager_remove_camera), -1);
  rb_define_method(SwigClassPageManager.klass, "has_camera", VALUEFUNC(_wrap_PageManager_has_camera), -1);
  rb_define_method(SwigClassPageManager.klass, "get_camera_list", VALUEFUNC(_wrap_PageManager_get_camera_list), -1);
  rb_define_method(SwigClassPageManager.klass, "set_debug_display_level", VALUEFUNC(_wrap_PageManager_set_debug_display_level), -1);
  rb_define_method(SwigClassPageManager.klass, "get_debug_display_level", VALUEFUNC(_wrap_PageManager_get_debug_display_level), -1);
  rb_define_method(SwigClassPageManager.klass, "set_paging_operations_enabled", VALUEFUNC(_wrap_PageManager_set_paging_operations_enabled), -1);
  rb_define_method(SwigClassPageManager.klass, "get_paging_operations_enabled", VALUEFUNC(_wrap_PageManager_get_paging_operations_enabled), -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, "get_name", VALUEFUNC(_wrap_PagedWorld_get_name), -1);
  rb_define_method(SwigClassPagedWorld.klass, "get_manager", VALUEFUNC(_wrap_PagedWorld_get_manager), -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, "create_section", VALUEFUNC(_wrap_PagedWorld_create_section), -1);
  rb_define_method(SwigClassPagedWorld.klass, "destroy_section", VALUEFUNC(_wrap_PagedWorld_destroy_section), -1);
  rb_define_method(SwigClassPagedWorld.klass, "destroy_all_sections", VALUEFUNC(_wrap_PagedWorld_destroy_all_sections), -1);
  rb_define_method(SwigClassPagedWorld.klass, "get_section_count", VALUEFUNC(_wrap_PagedWorld_get_section_count), -1);
  rb_define_method(SwigClassPagedWorld.klass, "get_section", VALUEFUNC(_wrap_PagedWorld_get_section), -1);
  rb_define_method(SwigClassPagedWorld.klass, "get_sections", VALUEFUNC(_wrap_PagedWorld_get_sections), -1);
  rb_define_method(SwigClassPagedWorld.klass, "set_page_provider", VALUEFUNC(_wrap_PagedWorld_set_page_provider), -1);
  rb_define_method(SwigClassPagedWorld.klass, "get_page_provider", VALUEFUNC(_wrap_PagedWorld_get_page_provider), -1);
  rb_define_method(SwigClassPagedWorld.klass, "_prepare_procedural_page", VALUEFUNC(_wrap_PagedWorld__prepare_procedural_page), -1);
  rb_define_method(SwigClassPagedWorld.klass, "_load_procedural_page", VALUEFUNC(_wrap_PagedWorld__load_procedural_page), -1);
  rb_define_method(SwigClassPagedWorld.klass, "_unload_procedural_page", VALUEFUNC(_wrap_PagedWorld__unload_procedural_page), -1);
  rb_define_method(SwigClassPagedWorld.klass, "_unprepare_procedural_page", VALUEFUNC(_wrap_PagedWorld__unprepare_procedural_page), -1);
  rb_define_method(SwigClassPagedWorld.klass, "_read_page_stream", VALUEFUNC(_wrap_PagedWorld__read_page_stream), -1);
  rb_define_method(SwigClassPagedWorld.klass, "_write_page_stream", VALUEFUNC(_wrap_PagedWorld__write_page_stream), -1);
  rb_define_method(SwigClassPagedWorld.klass, "frame_start", VALUEFUNC(_wrap_PagedWorld_frame_start), -1);
  rb_define_method(SwigClassPagedWorld.klass, "frame_end", VALUEFUNC(_wrap_PagedWorld_frame_end), -1);
  rb_define_method(SwigClassPagedWorld.klass, "notify_camera", VALUEFUNC(_wrap_PagedWorld_notify_camera), -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, "get_manager", VALUEFUNC(_wrap_PagedWorldSection_get_manager), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "get_name", VALUEFUNC(_wrap_PagedWorldSection_get_name), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "get_strategy", VALUEFUNC(_wrap_PagedWorldSection_get_strategy), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "set_strategy", VALUEFUNC(_wrap_PagedWorldSection_set_strategy), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "set_scene_manager", VALUEFUNC(_wrap_PagedWorldSection_set_scene_manager), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "get_scene_manager", VALUEFUNC(_wrap_PagedWorldSection_get_scene_manager), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "get_world", VALUEFUNC(_wrap_PagedWorldSection_get_world), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "get_strategy_data", VALUEFUNC(_wrap_PagedWorldSection_get_strategy_data), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "set_bounding_box", VALUEFUNC(_wrap_PagedWorldSection_set_bounding_box), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "get_bounding_box", VALUEFUNC(_wrap_PagedWorldSection_get_bounding_box), -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, "frame_start", VALUEFUNC(_wrap_PagedWorldSection_frame_start), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "frame_end", VALUEFUNC(_wrap_PagedWorldSection_frame_end), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "notify_camera", VALUEFUNC(_wrap_PagedWorldSection_notify_camera), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "load_or_create_page", VALUEFUNC(_wrap_PagedWorldSection_load_or_create_page), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "get_page_id", VALUEFUNC(_wrap_PagedWorldSection_get_page_id), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "load_page", VALUEFUNC(_wrap_PagedWorldSection_load_page), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "unload_page", VALUEFUNC(_wrap_PagedWorldSection_unload_page), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "_prepare_procedural_page", VALUEFUNC(_wrap_PagedWorldSection__prepare_procedural_page), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "_load_procedural_page", VALUEFUNC(_wrap_PagedWorldSection__load_procedural_page), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "_unload_procedural_page", VALUEFUNC(_wrap_PagedWorldSection__unload_procedural_page), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "_unprepare_procedural_page", VALUEFUNC(_wrap_PagedWorldSection__unprepare_procedural_page), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "hold_page", VALUEFUNC(_wrap_PagedWorldSection_hold_page), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "get_page", VALUEFUNC(_wrap_PagedWorldSection_get_page), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "remove_all_pages", VALUEFUNC(_wrap_PagedWorldSection_remove_all_pages), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "set_page_provider", VALUEFUNC(_wrap_PagedWorldSection_set_page_provider), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "get_page_provider", VALUEFUNC(_wrap_PagedWorldSection_get_page_provider), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "_read_page_stream", VALUEFUNC(_wrap_PagedWorldSection__read_page_stream), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "_write_page_stream", VALUEFUNC(_wrap_PagedWorldSection__write_page_stream), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "get_type", VALUEFUNC(_wrap_PagedWorldSection_get_type), -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, "get_name", VALUEFUNC(_wrap_PagedWorldSectionFactory_get_name), -1);
  rb_define_method(SwigClassPagedWorldSectionFactory.klass, "create_instance", VALUEFUNC(_wrap_PagedWorldSectionFactory_create_instance), -1);
  rb_define_method(SwigClassPagedWorldSectionFactory.klass, "destroy_instance", VALUEFUNC(_wrap_PagedWorldSectionFactory_destroy_instance), -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, "create_content", VALUEFUNC(_wrap_SimplePageContentCollection_create_content), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "destroy_content", VALUEFUNC(_wrap_SimplePageContentCollection_destroy_content), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "get_content_list", VALUEFUNC(_wrap_SimplePageContentCollection_get_content_list), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "save", VALUEFUNC(_wrap_SimplePageContentCollection_save), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "frame_start", VALUEFUNC(_wrap_SimplePageContentCollection_frame_start), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "frame_end", VALUEFUNC(_wrap_SimplePageContentCollection_frame_end), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "notify_camera", VALUEFUNC(_wrap_SimplePageContentCollection_notify_camera), -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, "get_name", VALUEFUNC(_wrap_SimplePageContentCollectionFactory_get_name), -1);
  rb_define_method(SwigClassSimplePageContentCollectionFactory.klass, "create_instance", VALUEFUNC(_wrap_SimplePageContentCollectionFactory_create_instance), -1);
  rb_define_method(SwigClassSimplePageContentCollectionFactory.klass, "destroy_instance", VALUEFUNC(_wrap_SimplePageContentCollectionFactory_destroy_instance), -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, "get_default_import_settings", VALUEFUNC(_wrap_TerrainGroup_get_default_import_settings), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "set_origin", VALUEFUNC(_wrap_TerrainGroup_set_origin), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "get_origin", VALUEFUNC(_wrap_TerrainGroup_get_origin), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "get_alignment", VALUEFUNC(_wrap_TerrainGroup_get_alignment), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "get_terrain_world_size", VALUEFUNC(_wrap_TerrainGroup_get_terrain_world_size), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "set_terrain_world_size", VALUEFUNC(_wrap_TerrainGroup_set_terrain_world_size), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "get_terrain_size", VALUEFUNC(_wrap_TerrainGroup_get_terrain_size), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "set_terrain_size", VALUEFUNC(_wrap_TerrainGroup_set_terrain_size), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "get_scene_manager", VALUEFUNC(_wrap_TerrainGroup_get_scene_manager), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "set_filename_convention", VALUEFUNC(_wrap_TerrainGroup_set_filename_convention), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "set_filename_prefix", VALUEFUNC(_wrap_TerrainGroup_set_filename_prefix), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "set_filename_extension", VALUEFUNC(_wrap_TerrainGroup_set_filename_extension), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "get_filename_prefix", VALUEFUNC(_wrap_TerrainGroup_get_filename_prefix), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "get_filename_extension", VALUEFUNC(_wrap_TerrainGroup_get_filename_extension), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "set_resource_group", VALUEFUNC(_wrap_TerrainGroup_set_resource_group), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "get_resource_group", VALUEFUNC(_wrap_TerrainGroup_get_resource_group), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "define_terrain", VALUEFUNC(_wrap_TerrainGroup_define_terrain), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "load_all_terrains", VALUEFUNC(_wrap_TerrainGroup_load_all_terrains), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "load_terrain", VALUEFUNC(_wrap_TerrainGroup_load_terrain), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "unload_terrain", VALUEFUNC(_wrap_TerrainGroup_unload_terrain), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "remove_terrain", VALUEFUNC(_wrap_TerrainGroup_remove_terrain), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "remove_all_terrains", VALUEFUNC(_wrap_TerrainGroup_remove_all_terrains), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "save_all_terrains", VALUEFUNC(_wrap_TerrainGroup_save_all_terrains), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "get_terrain_definition", VALUEFUNC(_wrap_TerrainGroup_get_terrain_definition), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "get_terrain", VALUEFUNC(_wrap_TerrainGroup_get_terrain), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "free_temporary_resources", VALUEFUNC(_wrap_TerrainGroup_free_temporary_resources), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "update", VALUEFUNC(_wrap_TerrainGroup_update), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "update_geometry", VALUEFUNC(_wrap_TerrainGroup_update_geometry), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "update_derived_data", VALUEFUNC(_wrap_TerrainGroup_update_derived_data), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "get_height_at_world_position", VALUEFUNC(_wrap_TerrainGroup_get_height_at_world_position), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "ray_intersects", VALUEFUNC(_wrap_TerrainGroup_ray_intersects), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "box_intersects", VALUEFUNC(_wrap_TerrainGroup_box_intersects), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "sphere_intersects", VALUEFUNC(_wrap_TerrainGroup_sphere_intersects), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "convert_world_position_to_terrain_slot", VALUEFUNC(_wrap_TerrainGroup_convert_world_position_to_terrain_slot), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "convert_terrain_slot_to_world_position", VALUEFUNC(_wrap_TerrainGroup_convert_terrain_slot_to_world_position), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "is_derived_data_update_in_progress", VALUEFUNC(_wrap_TerrainGroup_is_derived_data_update_in_progress), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "get_terrain_iterator", VALUEFUNC(_wrap_TerrainGroup_get_terrain_iterator), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "can_handle_request", VALUEFUNC(_wrap_TerrainGroup_can_handle_request), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "handle_request", VALUEFUNC(_wrap_TerrainGroup_handle_request), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "can_handle_response", VALUEFUNC(_wrap_TerrainGroup_can_handle_response), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "handle_response", VALUEFUNC(_wrap_TerrainGroup_handle_response), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "pack_index", VALUEFUNC(_wrap_TerrainGroup_pack_index), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "unpack_index", VALUEFUNC(_wrap_TerrainGroup_unpack_index), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "generate_filename", VALUEFUNC(_wrap_TerrainGroup_generate_filename), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "save_group_definition", VALUEFUNC(_wrap_TerrainGroup_save_group_definition), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "load_group_definition", VALUEFUNC(_wrap_TerrainGroup_load_group_definition), -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, "set_default_import_settings", VALUEFUNC(_wrap_TerrainGroup_set_default_import_settings), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "init_blend_maps", VALUEFUNC(_wrap_TerrainGroup_init_blend_maps), -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, "get_parent", VALUEFUNC(_wrap_TerrainLayerBlendMap_get_parent), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "get_layer_index", VALUEFUNC(_wrap_TerrainLayerBlendMap_get_layer_index), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "convert_world_to_uvspace", VALUEFUNC(_wrap_TerrainLayerBlendMap_convert_world_to_uvspace), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "convert_uvto_world_space", VALUEFUNC(_wrap_TerrainLayerBlendMap_convert_uvto_world_space), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "convert_uvto_image_space", VALUEFUNC(_wrap_TerrainLayerBlendMap_convert_uvto_image_space), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "convert_image_to_uvspace", VALUEFUNC(_wrap_TerrainLayerBlendMap_convert_image_to_uvspace), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "convert_image_to_terrain_space", VALUEFUNC(_wrap_TerrainLayerBlendMap_convert_image_to_terrain_space), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "convert_terrain_to_image_space", VALUEFUNC(_wrap_TerrainLayerBlendMap_convert_terrain_to_image_space), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "get_blend_value", VALUEFUNC(_wrap_TerrainLayerBlendMap_get_blend_value), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "set_blend_value", VALUEFUNC(_wrap_TerrainLayerBlendMap_set_blend_value), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "get_blend_pointer", VALUEFUNC(_wrap_TerrainLayerBlendMap_get_blend_pointer), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "dirty", VALUEFUNC(_wrap_TerrainLayerBlendMap_dirty), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "dirty_rect", VALUEFUNC(_wrap_TerrainLayerBlendMap_dirty_rect), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "blit", VALUEFUNC(_wrap_TerrainLayerBlendMap_blit), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "load_image", VALUEFUNC(_wrap_TerrainLayerBlendMap_load_image), -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, "get_profiles", VALUEFUNC(_wrap_TerrainMaterialGenerator_get_profiles), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "set_active_profile", VALUEFUNC(_wrap_TerrainMaterialGenerator_set_active_profile), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "get_active_profile", VALUEFUNC(_wrap_TerrainMaterialGenerator_get_active_profile), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "_mark_changed", VALUEFUNC(_wrap_TerrainMaterialGenerator__mark_changed), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "get_change_count", VALUEFUNC(_wrap_TerrainMaterialGenerator_get_change_count), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "get_layer_declaration", VALUEFUNC(_wrap_TerrainMaterialGenerator_get_layer_declaration), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "can_generate_using_declaration", VALUEFUNC(_wrap_TerrainMaterialGenerator_can_generate_using_declaration), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "is_vertex_compression_supported", VALUEFUNC(_wrap_TerrainMaterialGenerator_is_vertex_compression_supported), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "request_options", VALUEFUNC(_wrap_TerrainMaterialGenerator_request_options), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "generate", VALUEFUNC(_wrap_TerrainMaterialGenerator_generate), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "generate_for_composite_map", VALUEFUNC(_wrap_TerrainMaterialGenerator_generate_for_composite_map), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "get_max_layers", VALUEFUNC(_wrap_TerrainMaterialGenerator_get_max_layers), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "update_composite_map", VALUEFUNC(_wrap_TerrainMaterialGenerator_update_composite_map), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "update_params", VALUEFUNC(_wrap_TerrainMaterialGenerator_update_params), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "update_params_for_composite_map", VALUEFUNC(_wrap_TerrainMaterialGenerator_update_params_for_composite_map), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "set_debug_level", VALUEFUNC(_wrap_TerrainMaterialGenerator_set_debug_level), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "get_debug_level", VALUEFUNC(_wrap_TerrainMaterialGenerator_get_debug_level), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "_render_composite_map", VALUEFUNC(_wrap_TerrainMaterialGenerator__render_composite_map), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "_get_composite_map_rtt", VALUEFUNC(_wrap_TerrainMaterialGenerator__get_composite_map_rtt), -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, "get_terrain_group", VALUEFUNC(_wrap_TerrainPagedWorldSection_get_terrain_group), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "set_load_radius", VALUEFUNC(_wrap_TerrainPagedWorldSection_set_load_radius), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "get_load_radius", VALUEFUNC(_wrap_TerrainPagedWorldSection_get_load_radius), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "set_hold_radius", VALUEFUNC(_wrap_TerrainPagedWorldSection_set_hold_radius), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "get_hold_radius", VALUEFUNC(_wrap_TerrainPagedWorldSection_get_hold_radius), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "set_page_range", VALUEFUNC(_wrap_TerrainPagedWorldSection_set_page_range), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "set_page_range_min_x", VALUEFUNC(_wrap_TerrainPagedWorldSection_set_page_range_min_x), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "set_page_range_min_y", VALUEFUNC(_wrap_TerrainPagedWorldSection_set_page_range_min_y), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "set_page_range_max_x", VALUEFUNC(_wrap_TerrainPagedWorldSection_set_page_range_max_x), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "set_page_range_max_y", VALUEFUNC(_wrap_TerrainPagedWorldSection_set_page_range_max_y), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "get_page_range_min_x", VALUEFUNC(_wrap_TerrainPagedWorldSection_get_page_range_min_x), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "get_page_range_min_y", VALUEFUNC(_wrap_TerrainPagedWorldSection_get_page_range_min_y), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "get_page_range_max_x", VALUEFUNC(_wrap_TerrainPagedWorldSection_get_page_range_max_x), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "get_page_range_max_y", VALUEFUNC(_wrap_TerrainPagedWorldSection_get_page_range_max_y), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "get_grid_strategy", VALUEFUNC(_wrap_TerrainPagedWorldSection_get_grid_strategy), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "get_grid_strategy_data", VALUEFUNC(_wrap_TerrainPagedWorldSection_get_grid_strategy_data), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "load_page", VALUEFUNC(_wrap_TerrainPagedWorldSection_load_page), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "unload_page", VALUEFUNC(_wrap_TerrainPagedWorldSection_unload_page), -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, "create_world_section", VALUEFUNC(_wrap_TerrainPaging_create_world_section), -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, "get_xoffset", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_xoffset), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_yoffset", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_yoffset), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "is_leaf", VALUEFUNC(_wrap_TerrainQuadTreeNode_is_leaf), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_base_lod", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_base_lod), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_lod_count", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_lod_count), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_child", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_child), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_parent", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_parent), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_terrain", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_terrain), -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, "get_lod_level", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_lod_level), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "pre_delta_calculation", VALUEFUNC(_wrap_TerrainQuadTreeNode_pre_delta_calculation), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "notify_delta", VALUEFUNC(_wrap_TerrainQuadTreeNode_notify_delta), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "post_delta_calculation", VALUEFUNC(_wrap_TerrainQuadTreeNode_post_delta_calculation), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "finalise_delta_values", VALUEFUNC(_wrap_TerrainQuadTreeNode_finalise_delta_values), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "assign_vertex_data", VALUEFUNC(_wrap_TerrainQuadTreeNode_assign_vertex_data), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "use_ancestor_vertex_data", VALUEFUNC(_wrap_TerrainQuadTreeNode_use_ancestor_vertex_data), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "update_vertex_data", VALUEFUNC(_wrap_TerrainQuadTreeNode_update_vertex_data), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "merge_into_bounds", VALUEFUNC(_wrap_TerrainQuadTreeNode_merge_into_bounds), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "reset_bounds", VALUEFUNC(_wrap_TerrainQuadTreeNode_reset_bounds), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "rect_intersects_node", VALUEFUNC(_wrap_TerrainQuadTreeNode_rect_intersects_node), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "rect_contains_node", VALUEFUNC(_wrap_TerrainQuadTreeNode_rect_contains_node), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "point_intersects_node", VALUEFUNC(_wrap_TerrainQuadTreeNode_point_intersects_node), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_aabb", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_aabb), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_bounding_radius", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_bounding_radius), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_local_centre", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_local_centre), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_min_height", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_min_height), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_max_height", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_max_height), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "calculate_current_lod", VALUEFUNC(_wrap_TerrainQuadTreeNode_calculate_current_lod), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_current_lod", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_current_lod), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "is_rendered_at_current_lod", VALUEFUNC(_wrap_TerrainQuadTreeNode_is_rendered_at_current_lod), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "is_self_or_child_rendered_at_current_lod", VALUEFUNC(_wrap_TerrainQuadTreeNode_is_self_or_child_rendered_at_current_lod), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "set_current_lod", VALUEFUNC(_wrap_TerrainQuadTreeNode_set_current_lod), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "get_lod_transition", VALUEFUNC(_wrap_TerrainQuadTreeNode_get_lod_transition), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "set_lod_transition", VALUEFUNC(_wrap_TerrainQuadTreeNode_set_lod_transition), -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, "_get_renderable", VALUEFUNC(_wrap_TerrainQuadTreeNode__get_renderable), -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, "get_scene_manager", VALUEFUNC(_wrap_Terrain_get_scene_manager), -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, "set_gpu_buffer_allocator", VALUEFUNC(_wrap_Terrain_set_gpu_buffer_allocator), -1);
  rb_define_method(SwigClassTerrain.klass, "get_gpu_buffer_allocator", VALUEFUNC(_wrap_Terrain_get_gpu_buffer_allocator), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "_get_num_indexes_for_batch_size", VALUEFUNC(_wrap_Terrain__get_num_indexes_for_batch_size), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "_populate_index_buffer", VALUEFUNC(_wrap_Terrain__populate_index_buffer), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "_calc_skirt_vertex_index", VALUEFUNC(_wrap_Terrain__calc_skirt_vertex_index), -1);
  rb_define_method(SwigClassTerrain.klass, "convert_position", VALUEFUNC(_wrap_Terrain_convert_position), -1);
  rb_define_method(SwigClassTerrain.klass, "convert_direction", VALUEFUNC(_wrap_Terrain_convert_direction), -1);
  rb_define_method(SwigClassTerrain.klass, "set_resource_group", VALUEFUNC(_wrap_Terrain_set_resource_group), -1);
  rb_define_method(SwigClassTerrain.klass, "get_resource_group", VALUEFUNC(_wrap_Terrain_get_resource_group), -1);
  rb_define_method(SwigClassTerrain.klass, "_get_derived_resource_group", VALUEFUNC(_wrap_Terrain__get_derived_resource_group), -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, "is_loaded", VALUEFUNC(_wrap_Terrain_is_loaded), -1);
  rb_define_method(SwigClassTerrain.klass, "is_modified", VALUEFUNC(_wrap_Terrain_is_modified), -1);
  rb_define_method(SwigClassTerrain.klass, "is_height_data_modified", VALUEFUNC(_wrap_Terrain_is_height_data_modified), -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, "get_height_data", VALUEFUNC(_wrap_Terrain_get_height_data), -1);
  rb_define_method(SwigClassTerrain.klass, "get_height_at_point", VALUEFUNC(_wrap_Terrain_get_height_at_point), -1);
  rb_define_method(SwigClassTerrain.klass, "set_height_at_point", VALUEFUNC(_wrap_Terrain_set_height_at_point), -1);
  rb_define_method(SwigClassTerrain.klass, "get_height_at_terrain_position", VALUEFUNC(_wrap_Terrain_get_height_at_terrain_position), -1);
  rb_define_method(SwigClassTerrain.klass, "get_height_at_world_position", VALUEFUNC(_wrap_Terrain_get_height_at_world_position), -1);
  rb_define_method(SwigClassTerrain.klass, "get_delta_data", VALUEFUNC(_wrap_Terrain_get_delta_data), -1);
  rb_define_method(SwigClassTerrain.klass, "get_point_from_self_or_neighbour", VALUEFUNC(_wrap_Terrain_get_point_from_self_or_neighbour), -1);
  rb_define_method(SwigClassTerrain.klass, "get_point", VALUEFUNC(_wrap_Terrain_get_point), -1);
  rb_define_method(SwigClassTerrain.klass, "get_point_transform", VALUEFUNC(_wrap_Terrain_get_point_transform), -1);
  rb_define_method(SwigClassTerrain.klass, "get_terrain_vector", VALUEFUNC(_wrap_Terrain_get_terrain_vector), -1);
  rb_define_method(SwigClassTerrain.klass, "get_terrain_vector_align", VALUEFUNC(_wrap_Terrain_get_terrain_vector_align), -1);
  rb_define_method(SwigClassTerrain.klass, "get_vector", VALUEFUNC(_wrap_Terrain_get_vector), -1);
  rb_define_method(SwigClassTerrain.klass, "get_vector_align", VALUEFUNC(_wrap_Terrain_get_vector_align), -1);
  rb_define_method(SwigClassTerrain.klass, "get_terrain_position", VALUEFUNC(_wrap_Terrain_get_terrain_position), -1);
  rb_define_method(SwigClassTerrain.klass, "get_position_align", VALUEFUNC(_wrap_Terrain_get_position_align), -1);
  rb_define_method(SwigClassTerrain.klass, "get_terrain_position_align", VALUEFUNC(_wrap_Terrain_get_terrain_position_align), -1);
  rb_define_method(SwigClassTerrain.klass, "get_alignment", VALUEFUNC(_wrap_Terrain_get_alignment), -1);
  rb_define_method(SwigClassTerrain.klass, "get_size", VALUEFUNC(_wrap_Terrain_get_size), -1);
  rb_define_method(SwigClassTerrain.klass, "set_size", VALUEFUNC(_wrap_Terrain_set_size), -1);
  rb_define_method(SwigClassTerrain.klass, "get_max_batch_size", VALUEFUNC(_wrap_Terrain_get_max_batch_size), -1);
  rb_define_method(SwigClassTerrain.klass, "get_min_batch_size", VALUEFUNC(_wrap_Terrain_get_min_batch_size), -1);
  rb_define_method(SwigClassTerrain.klass, "get_world_size", VALUEFUNC(_wrap_Terrain_get_world_size), -1);
  rb_define_method(SwigClassTerrain.klass, "set_world_size", VALUEFUNC(_wrap_Terrain_set_world_size), -1);
  rb_define_method(SwigClassTerrain.klass, "get_layer_count", VALUEFUNC(_wrap_Terrain_get_layer_count), -1);
  rb_define_method(SwigClassTerrain.klass, "get_layer_declaration", VALUEFUNC(_wrap_Terrain_get_layer_declaration), -1);
  rb_define_method(SwigClassTerrain.klass, "add_layer", VALUEFUNC(_wrap_Terrain_add_layer), -1);
  rb_define_method(SwigClassTerrain.klass, "remove_layer", VALUEFUNC(_wrap_Terrain_remove_layer), -1);
  rb_define_method(SwigClassTerrain.klass, "replace_layer", VALUEFUNC(_wrap_Terrain_replace_layer), -1);
  rb_define_method(SwigClassTerrain.klass, "get_max_layers", VALUEFUNC(_wrap_Terrain_get_max_layers), -1);
  rb_define_method(SwigClassTerrain.klass, "get_layer_world_size", VALUEFUNC(_wrap_Terrain_get_layer_world_size), -1);
  rb_define_method(SwigClassTerrain.klass, "set_layer_world_size", VALUEFUNC(_wrap_Terrain_set_layer_world_size), -1);
  rb_define_method(SwigClassTerrain.klass, "get_layer_uvmultiplier", VALUEFUNC(_wrap_Terrain_get_layer_uvmultiplier), -1);
  rb_define_method(SwigClassTerrain.klass, "get_layer_texture_name", VALUEFUNC(_wrap_Terrain_get_layer_texture_name), -1);
  rb_define_method(SwigClassTerrain.klass, "set_layer_texture_name", VALUEFUNC(_wrap_Terrain_set_layer_texture_name), -1);
  rb_define_method(SwigClassTerrain.klass, "get_layer_blend_map_size", VALUEFUNC(_wrap_Terrain_get_layer_blend_map_size), -1);
  rb_define_method(SwigClassTerrain.klass, "get_lightmap_size", VALUEFUNC(_wrap_Terrain_get_lightmap_size), -1);
  rb_define_method(SwigClassTerrain.klass, "get_lightmap", VALUEFUNC(_wrap_Terrain_get_lightmap), -1);
  rb_define_method(SwigClassTerrain.klass, "get_composite_map_size", VALUEFUNC(_wrap_Terrain_get_composite_map_size), -1);
  rb_define_method(SwigClassTerrain.klass, "get_composite_map", VALUEFUNC(_wrap_Terrain_get_composite_map), -1);
  rb_define_method(SwigClassTerrain.klass, "get_position", VALUEFUNC(_wrap_Terrain_get_position), -1);
  rb_define_method(SwigClassTerrain.klass, "set_position", VALUEFUNC(_wrap_Terrain_set_position), -1);
  rb_define_method(SwigClassTerrain.klass, "_get_root_scene_node", VALUEFUNC(_wrap_Terrain__get_root_scene_node), -1);
  rb_define_method(SwigClassTerrain.klass, "dirty", VALUEFUNC(_wrap_Terrain_dirty), -1);
  rb_define_method(SwigClassTerrain.klass, "dirty_rect", VALUEFUNC(_wrap_Terrain_dirty_rect), -1);
  rb_define_method(SwigClassTerrain.klass, "_dirty_composite_map_rect", VALUEFUNC(_wrap_Terrain__dirty_composite_map_rect), -1);
  rb_define_method(SwigClassTerrain.klass, "dirty_lightmap_rect", VALUEFUNC(_wrap_Terrain_dirty_lightmap_rect), -1);
  rb_define_method(SwigClassTerrain.klass, "dirty_lightmap", VALUEFUNC(_wrap_Terrain_dirty_lightmap), -1);
  rb_define_method(SwigClassTerrain.klass, "update", VALUEFUNC(_wrap_Terrain_update), -1);
  rb_define_method(SwigClassTerrain.klass, "update_geometry", VALUEFUNC(_wrap_Terrain_update_geometry), -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, "update_derived_data", VALUEFUNC(_wrap_Terrain_update_derived_data), -1);
  rb_define_method(SwigClassTerrain.klass, "update_composite_map", VALUEFUNC(_wrap_Terrain_update_composite_map), -1);
  rb_define_method(SwigClassTerrain.klass, "update_composite_map_with_delay", VALUEFUNC(_wrap_Terrain_update_composite_map_with_delay), -1);
  rb_define_method(SwigClassTerrain.klass, "get_skirt_size", VALUEFUNC(_wrap_Terrain_get_skirt_size), -1);
  rb_define_method(SwigClassTerrain.klass, "get_num_lod_levels", VALUEFUNC(_wrap_Terrain_get_num_lod_levels), -1);
  rb_define_method(SwigClassTerrain.klass, "get_num_lod_levels_per_leaf", VALUEFUNC(_wrap_Terrain_get_num_lod_levels_per_leaf), -1);
  rb_define_method(SwigClassTerrain.klass, "calculate_height_deltas", VALUEFUNC(_wrap_Terrain_calculate_height_deltas), -1);
  rb_define_method(SwigClassTerrain.klass, "finalise_height_deltas", VALUEFUNC(_wrap_Terrain_finalise_height_deltas), -1);
  rb_define_method(SwigClassTerrain.klass, "calculate_normals", VALUEFUNC(_wrap_Terrain_calculate_normals), -1);
  rb_define_method(SwigClassTerrain.klass, "finalise_normals", VALUEFUNC(_wrap_Terrain_finalise_normals), -1);
  rb_define_method(SwigClassTerrain.klass, "calculate_lightmap", VALUEFUNC(_wrap_Terrain_calculate_lightmap), -1);
  rb_define_method(SwigClassTerrain.klass, "finalise_lightmap", VALUEFUNC(_wrap_Terrain_finalise_lightmap), -1);
  rb_define_method(SwigClassTerrain.klass, "get_resolution_at_lod", VALUEFUNC(_wrap_Terrain_get_resolution_at_lod), -1);
  rb_define_method(SwigClassTerrain.klass, "ray_intersects", VALUEFUNC(_wrap_Terrain_ray_intersects), -1);
  rb_define_method(SwigClassTerrain.klass, "get_aabb", VALUEFUNC(_wrap_Terrain_get_aabb), -1);
  rb_define_method(SwigClassTerrain.klass, "get_world_aabb", VALUEFUNC(_wrap_Terrain_get_world_aabb), -1);
  rb_define_method(SwigClassTerrain.klass, "get_min_height", VALUEFUNC(_wrap_Terrain_get_min_height), -1);
  rb_define_method(SwigClassTerrain.klass, "get_max_height", VALUEFUNC(_wrap_Terrain_get_max_height), -1);
  rb_define_method(SwigClassTerrain.klass, "get_bounding_radius", VALUEFUNC(_wrap_Terrain_get_bounding_radius), -1);
  rb_define_method(SwigClassTerrain.klass, "get_material", VALUEFUNC(_wrap_Terrain_get_material), -1);
  rb_define_method(SwigClassTerrain.klass, "_get_material", VALUEFUNC(_wrap_Terrain__get_material), -1);
  rb_define_method(SwigClassTerrain.klass, "get_composite_map_material", VALUEFUNC(_wrap_Terrain_get_composite_map_material), -1);
  rb_define_method(SwigClassTerrain.klass, "_get_composite_map_material", VALUEFUNC(_wrap_Terrain__get_composite_map_material), -1);
  rb_define_method(SwigClassTerrain.klass, "get_material_name", VALUEFUNC(_wrap_Terrain_get_material_name), -1);
  rb_define_method(SwigClassTerrain.klass, "pre_find_visible_objects", VALUEFUNC(_wrap_Terrain_pre_find_visible_objects), -1);
  rb_define_method(SwigClassTerrain.klass, "scene_manager_destroyed", VALUEFUNC(_wrap_Terrain_scene_manager_destroyed), -1);
  rb_define_method(SwigClassTerrain.klass, "get_render_queue_group", VALUEFUNC(_wrap_Terrain_get_render_queue_group), -1);
  rb_define_method(SwigClassTerrain.klass, "set_render_queue_group", VALUEFUNC(_wrap_Terrain_set_render_queue_group), -1);
  rb_define_method(SwigClassTerrain.klass, "get_visibility_flags", VALUEFUNC(_wrap_Terrain_get_visibility_flags), -1);
  rb_define_method(SwigClassTerrain.klass, "set_visibility_flags", VALUEFUNC(_wrap_Terrain_set_visibility_flags), -1);
  rb_define_method(SwigClassTerrain.klass, "get_query_flags", VALUEFUNC(_wrap_Terrain_get_query_flags), -1);
  rb_define_method(SwigClassTerrain.klass, "set_query_flags", VALUEFUNC(_wrap_Terrain_set_query_flags), -1);
  rb_define_method(SwigClassTerrain.klass, "add_query_flags", VALUEFUNC(_wrap_Terrain_add_query_flags), -1);
  rb_define_method(SwigClassTerrain.klass, "remove_query_flags", VALUEFUNC(_wrap_Terrain_remove_query_flags), -1);
  rb_define_method(SwigClassTerrain.klass, "get_layer_blend_map", VALUEFUNC(_wrap_Terrain_get_layer_blend_map), -1);
  rb_define_method(SwigClassTerrain.klass, "get_blend_texture_index", VALUEFUNC(_wrap_Terrain_get_blend_texture_index), -1);
  rb_define_method(SwigClassTerrain.klass, "get_blend_texture_count", VALUEFUNC(_wrap_Terrain_get_blend_texture_count), -1);
  rb_define_method(SwigClassTerrain.klass, "get_blend_texture_name", VALUEFUNC(_wrap_Terrain_get_blend_texture_name), -1);
  rb_define_method(SwigClassTerrain.klass, "set_global_colour_map_enabled", VALUEFUNC(_wrap_Terrain_set_global_colour_map_enabled), -1);
  rb_define_method(SwigClassTerrain.klass, "get_global_colour_map_enabled", VALUEFUNC(_wrap_Terrain_get_global_colour_map_enabled), -1);
  rb_define_method(SwigClassTerrain.klass, "get_global_colour_map_size", VALUEFUNC(_wrap_Terrain_get_global_colour_map_size), -1);
  rb_define_method(SwigClassTerrain.klass, "get_global_colour_map", VALUEFUNC(_wrap_Terrain_get_global_colour_map), -1);
  rb_define_method(SwigClassTerrain.klass, "widen_rect_by_vector", VALUEFUNC(_wrap_Terrain_widen_rect_by_vector), -1);
  rb_define_method(SwigClassTerrain.klass, "free_temporary_resources", VALUEFUNC(_wrap_Terrain_free_temporary_resources), -1);
  rb_define_method(SwigClassTerrain.klass, "get_layer_blend_texture", VALUEFUNC(_wrap_Terrain_get_layer_blend_texture), -1);
  rb_define_method(SwigClassTerrain.klass, "get_layer_blend_texture_index", VALUEFUNC(_wrap_Terrain_get_layer_blend_texture_index), -1);
  rb_define_method(SwigClassTerrain.klass, "_set_morph_required", VALUEFUNC(_wrap_Terrain__set_morph_required), -1);
  rb_define_method(SwigClassTerrain.klass, "_get_morph_required", VALUEFUNC(_wrap_Terrain__get_morph_required), -1);
  rb_define_method(SwigClassTerrain.klass, "_set_normal_map_required", VALUEFUNC(_wrap_Terrain__set_normal_map_required), -1);
  rb_define_method(SwigClassTerrain.klass, "_set_light_map_required", VALUEFUNC(_wrap_Terrain__set_light_map_required), -1);
  rb_define_method(SwigClassTerrain.klass, "_set_composite_map_required", VALUEFUNC(_wrap_Terrain__set_composite_map_required), -1);
  rb_define_method(SwigClassTerrain.klass, "_get_use_vertex_compression", VALUEFUNC(_wrap_Terrain__get_use_vertex_compression), -1);
  rb_define_method(SwigClassTerrain.klass, "can_handle_request", VALUEFUNC(_wrap_Terrain_can_handle_request), -1);
  rb_define_method(SwigClassTerrain.klass, "handle_request", VALUEFUNC(_wrap_Terrain_handle_request), -1);
  rb_define_method(SwigClassTerrain.klass, "can_handle_response", VALUEFUNC(_wrap_Terrain_can_handle_response), -1);
  rb_define_method(SwigClassTerrain.klass, "handle_response", VALUEFUNC(_wrap_Terrain_handle_response), -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, "get_lodlevel_when_vertex_eliminated", VALUEFUNC(_wrap_Terrain_get_lodlevel_when_vertex_eliminated), -1);
  rb_define_method(SwigClassTerrain.klass, "get_quad_tree", VALUEFUNC(_wrap_Terrain_get_quad_tree), -1);
  rb_define_method(SwigClassTerrain.klass, "get_terrain_normal_map", VALUEFUNC(_wrap_Terrain_get_terrain_normal_map), -1);
  rb_define_method(SwigClassTerrain.klass, "get_neighbour", VALUEFUNC(_wrap_Terrain_get_neighbour), -1);
  rb_define_method(SwigClassTerrain.klass, "set_neighbour", VALUEFUNC(_wrap_Terrain_set_neighbour), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "get_opposite_neighbour", VALUEFUNC(_wrap_Terrain_get_opposite_neighbour), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "get_neighbour_index", VALUEFUNC(_wrap_Terrain_get_neighbour_index), -1);
  rb_define_method(SwigClassTerrain.klass, "notify_neighbours", VALUEFUNC(_wrap_Terrain_notify_neighbours), -1);
  rb_define_method(SwigClassTerrain.klass, "neighbour_modified", VALUEFUNC(_wrap_Terrain_neighbour_modified), -1);
  rb_define_method(SwigClassTerrain.klass, "ray_select_neighbour", VALUEFUNC(_wrap_Terrain_ray_select_neighbour), -1);
  rb_define_method(SwigClassTerrain.klass, "_dump_textures", VALUEFUNC(_wrap_Terrain__dump_textures), -1);
  rb_define_method(SwigClassTerrain.klass, "is_derived_data_update_in_progress", VALUEFUNC(_wrap_Terrain_is_derived_data_update_in_progress), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "convert_world_to_terrain_axes", VALUEFUNC(_wrap_Terrain_convert_world_to_terrain_axes), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "convert_terrain_to_world_axes", VALUEFUNC(_wrap_Terrain_convert_terrain_to_world_axes), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "write_layer_declaration", VALUEFUNC(_wrap_Terrain_write_layer_declaration), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "read_layer_declaration", VALUEFUNC(_wrap_Terrain_read_layer_declaration), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "write_layer_instance_list", VALUEFUNC(_wrap_Terrain_write_layer_instance_list), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "read_layer_instance_list", VALUEFUNC(_wrap_Terrain_read_layer_instance_list), -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, "get_skirt_size", VALUEFUNC(_wrap_TerrainGlobalOptions_get_skirt_size), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_skirt_size", VALUEFUNC(_wrap_TerrainGlobalOptions_set_skirt_size), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_light_map_direction", VALUEFUNC(_wrap_TerrainGlobalOptions_get_light_map_direction), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_light_map_direction", VALUEFUNC(_wrap_TerrainGlobalOptions_set_light_map_direction), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_composite_map_ambient", VALUEFUNC(_wrap_TerrainGlobalOptions_get_composite_map_ambient), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_composite_map_ambient", VALUEFUNC(_wrap_TerrainGlobalOptions_set_composite_map_ambient), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_composite_map_diffuse", VALUEFUNC(_wrap_TerrainGlobalOptions_get_composite_map_diffuse), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_composite_map_diffuse", VALUEFUNC(_wrap_TerrainGlobalOptions_set_composite_map_diffuse), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_composite_map_distance", VALUEFUNC(_wrap_TerrainGlobalOptions_get_composite_map_distance), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_composite_map_distance", VALUEFUNC(_wrap_TerrainGlobalOptions_set_composite_map_distance), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_casts_dynamic_shadows", VALUEFUNC(_wrap_TerrainGlobalOptions_get_casts_dynamic_shadows), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_casts_dynamic_shadows", VALUEFUNC(_wrap_TerrainGlobalOptions_set_casts_dynamic_shadows), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_max_pixel_error", VALUEFUNC(_wrap_TerrainGlobalOptions_get_max_pixel_error), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_max_pixel_error", VALUEFUNC(_wrap_TerrainGlobalOptions_set_max_pixel_error), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_render_queue_group", VALUEFUNC(_wrap_TerrainGlobalOptions_get_render_queue_group), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_render_queue_group", VALUEFUNC(_wrap_TerrainGlobalOptions_set_render_queue_group), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_visibility_flags", VALUEFUNC(_wrap_TerrainGlobalOptions_get_visibility_flags), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_visibility_flags", VALUEFUNC(_wrap_TerrainGlobalOptions_set_visibility_flags), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_query_flags", VALUEFUNC(_wrap_TerrainGlobalOptions_set_query_flags), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_query_flags", VALUEFUNC(_wrap_TerrainGlobalOptions_get_query_flags), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "add_query_flags", VALUEFUNC(_wrap_TerrainGlobalOptions_add_query_flags), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "remove_query_flags", VALUEFUNC(_wrap_TerrainGlobalOptions_remove_query_flags), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_use_ray_box_distance_calculation", VALUEFUNC(_wrap_TerrainGlobalOptions_get_use_ray_box_distance_calculation), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_use_ray_box_distance_calculation", VALUEFUNC(_wrap_TerrainGlobalOptions_set_use_ray_box_distance_calculation), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_default_material_generator", VALUEFUNC(_wrap_TerrainGlobalOptions_get_default_material_generator), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_default_material_generator", VALUEFUNC(_wrap_TerrainGlobalOptions_set_default_material_generator), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_layer_blend_map_size", VALUEFUNC(_wrap_TerrainGlobalOptions_get_layer_blend_map_size), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_layer_blend_map_size", VALUEFUNC(_wrap_TerrainGlobalOptions_set_layer_blend_map_size), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_default_layer_texture_world_size", VALUEFUNC(_wrap_TerrainGlobalOptions_get_default_layer_texture_world_size), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_default_layer_texture_world_size", VALUEFUNC(_wrap_TerrainGlobalOptions_set_default_layer_texture_world_size), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_default_global_colour_map_size", VALUEFUNC(_wrap_TerrainGlobalOptions_get_default_global_colour_map_size), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_default_global_colour_map_size", VALUEFUNC(_wrap_TerrainGlobalOptions_set_default_global_colour_map_size), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_light_map_size", VALUEFUNC(_wrap_TerrainGlobalOptions_get_light_map_size), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_light_map_size", VALUEFUNC(_wrap_TerrainGlobalOptions_set_light_map_size), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_composite_map_size", VALUEFUNC(_wrap_TerrainGlobalOptions_get_composite_map_size), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_composite_map_size", VALUEFUNC(_wrap_TerrainGlobalOptions_set_composite_map_size), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_default_resource_group", VALUEFUNC(_wrap_TerrainGlobalOptions_set_default_resource_group), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_default_resource_group", VALUEFUNC(_wrap_TerrainGlobalOptions_get_default_resource_group), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "get_use_vertex_compression_when_available", VALUEFUNC(_wrap_TerrainGlobalOptions_get_use_vertex_compression_when_available), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "set_use_vertex_compression_when_available", VALUEFUNC(_wrap_TerrainGlobalOptions_set_use_vertex_compression_when_available), -1);
  rb_define_singleton_method(SwigClassTerrainGlobalOptions.klass, "get_singleton", VALUEFUNC(_wrap_TerrainGlobalOptions_get_singleton), -1);
  rb_define_singleton_method(SwigClassTerrainGlobalOptions.klass, "get_singleton_ptr", VALUEFUNC(_wrap_TerrainGlobalOptions_get_singleton_ptr), -1);
  SwigClassTerrainGlobalOptions.mark = 0;
  SwigClassTerrainGlobalOptions.destroy = (void (*)(void *)) free_Ogre_TerrainGlobalOptions;
  SwigClassTerrainGlobalOptions.trackObjects = 0;
}