/*
** Lua binding: EmberOgre
** Generated automatically by tolua++-1.0.92 on Wed Nov 10 18:35:58 2010.
*/

#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "components/lua/tolua++.h"

/* Exported function */
TOLUA_API int  tolua_EmberOgre_open (lua_State* tolua_S);

#include "required.h"
#include "components/ogre/IGraphicalRepresentation.h"
#include "components/ogre/terrain/ISceneManagerAdapter.h"
#include "components/ogre/terrain/TerrainEditorOverlay.h"
#include "components/ogre/terrain/TerrainEditor.h"
#include "components/ogre/widgets/AssetsManager.h"
#include "components/ogre/widgets/AtlasHelper.h"
#include "components/ogre/widgets/Compass.h"
#include "components/ogre/widgets/adapters/eris/TypeTreeAdapter.h"
#include "components/ogre/widgets/adapters/ogre/ResourceListAdapter.h"
#include "components/ogre/widgets/EntityIconDragDropPreview.h"
#include "components/ogre/widgets/HelpMessage.h"
#include "components/ogre/widgets/QuickHelp.h"
#include "components/ogre/widgets/QuickHelpCursor.h"
#include "components/ogre/widgets/ActionBarInput.h"
#include "components/ogre/widgets/EntityTooltip.h"
#include "components/ogre/widgets/ActionBarIconSlot.h"
#include "components/ogre/widgets/ActionBarIcon.h"
#include "components/ogre/widgets/ActionBarIconManager.h"
#include <Eris/ServerInfo.h>
#include "components/ogre/widgets/ActionBarIconDragDropTarget.h"
#include "components/ogre/model/ModelRepresentation.h"
#include "components/ogre/model/ModelRepresentationManager.h"
#include "components/ogre/authoring/GUIAdapter.h"
#include "components/ogre/authoring/EntityRecipe.h"
#define __operator_ptr operator*
#define __operator_pp operator++
#include "components/ogre/authoring/EntityRecipeManager.h"
#include "components/ogre/widgets/EntityCreator.h"
#include "components/ogre/authoring/AuthoringManager.h"
#include "components/ogre/authoring/RawTypeInfoRepository.h"
#include "components/ogre/authoring/AtlasObjectDecoder.h"
#include "components/ogre/terrain/Map.h"
#include "components/ogre/terrain/TerrainLayerDefinition.h"
#include "components/ogre/terrain/TerrainLayerDefinitionManager.h"
#define __operator_ptr operator*
#define __operator_pp operator++
#include "components/ogre/World.h"
#include "components/ogre/Scene.h"

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_std__vector_EmberOgre__Model__SubModelDefinition__ (lua_State* tolua_S)
{
 std::vector<EmberOgre::Model::SubModelDefinition*>* self = (std::vector<EmberOgre::Model::SubModelDefinition*>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_std__set_std__string_ (lua_State* tolua_S)
{
 std::set<std::string>* self = (std::set<std::string>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Ogre__ResourceListAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter* self = (EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__RenderedCompassImpl (lua_State* tolua_S)
{
 EmberOgre::Gui::RenderedCompassImpl* self = (EmberOgre::Gui::RenderedCompassImpl*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__SimpleRenderContext (lua_State* tolua_S)
{
 EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Atlas__Objects__Root (lua_State* tolua_S)
{
 Atlas::Objects::Root* self = (Atlas::Objects::Root*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Authoring__EntityRecipeManager (lua_State* tolua_S)
{
 EmberOgre::Authoring::EntityRecipeManager* self = (EmberOgre::Authoring::EntityRecipeManager*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_std__vector_std__string_ (lua_State* tolua_S)
{
 std::vector<std::string>* self = (std::vector<std::string>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_size_t (lua_State* tolua_S)
{
 size_t* self = (size_t*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__EntityEditor (lua_State* tolua_S)
{
 EmberOgre::Gui::EntityEditor* self = (EmberOgre::Gui::EntityEditor*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__CompassCameraAnchor (lua_State* tolua_S)
{
 EmberOgre::Gui::CompassCameraAnchor* self = (EmberOgre::Gui::CompassCameraAnchor*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Model__Model (lua_State* tolua_S)
{
 EmberOgre::Model::Model* self = (EmberOgre::Model::Model*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__ConsoleAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::ConsoleAdapter* self = (EmberOgre::Gui::ConsoleAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_std__vector_EmberOgre__Model__SubEntityDefinition__ (lua_State* tolua_S)
{
 std::vector<EmberOgre::Model::SubEntityDefinition*>* self = (std::vector<EmberOgre::Model::SubEntityDefinition*>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Authoring__EntityRecipe (lua_State* tolua_S)
{
 EmberOgre::Authoring::EntityRecipe* self = (EmberOgre::Authoring::EntityRecipe*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__OgreEntityRenderer (lua_State* tolua_S)
{
 EmberOgre::Gui::OgreEntityRenderer* self = (EmberOgre::Gui::OgreEntityRenderer*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__IconBase (lua_State* tolua_S)
{
 EmberOgre::Gui::IconBase* self = (EmberOgre::Gui::IconBase*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Terrain__Map (lua_State* tolua_S)
{
 EmberOgre::Terrain::Map* self = (EmberOgre::Terrain::Map*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Terrain__TerrainArea (lua_State* tolua_S)
{
 EmberOgre::Terrain::TerrainArea* self = (EmberOgre::Terrain::TerrainArea*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__AssetsManager (lua_State* tolua_S)
{
 EmberOgre::Gui::AssetsManager* self = (EmberOgre::Gui::AssetsManager*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__CompassSceneNodeAnchor (lua_State* tolua_S)
{
 EmberOgre::Gui::CompassSceneNodeAnchor* self = (EmberOgre::Gui::CompassSceneNodeAnchor*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__TexturePair (lua_State* tolua_S)
{
 EmberOgre::Gui::TexturePair* self = (EmberOgre::Gui::TexturePair*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__EntityIconDragDropPreview (lua_State* tolua_S)
{
 EmberOgre::Gui::EntityIconDragDropPreview* self = (EmberOgre::Gui::EntityIconDragDropPreview*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Atlas__Message__Element (lua_State* tolua_S)
{
 Atlas::Message::Element* self = (Atlas::Message::Element*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Terrain__TerrainEditor (lua_State* tolua_S)
{
 EmberOgre::Terrain::TerrainEditor* self = (EmberOgre::Terrain::TerrainEditor*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_WFMath__Point_3_ (lua_State* tolua_S)
{
 WFMath::Point<3>* self = (WFMath::Point<3>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Authoring__EntityRecipePtr (lua_State* tolua_S)
{
 EmberOgre::Authoring::EntityRecipePtr* self = (EmberOgre::Authoring::EntityRecipePtr*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__IconBar (lua_State* tolua_S)
{
 EmberOgre::Gui::IconBar* self = (EmberOgre::Gui::IconBar*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Eris__TypeTreeAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter* self = (EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_std__vector_EmberOgre__Model__PartDefinition__ (lua_State* tolua_S)
{
 std::vector<EmberOgre::Model::PartDefinition*>* self = (std::vector<EmberOgre::Model::PartDefinition*>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__EntityPickResult (lua_State* tolua_S)
{
 EmberOgre::EntityPickResult* self = (EmberOgre::EntityPickResult*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__ActionBarInput (lua_State* tolua_S)
{
 EmberOgre::Gui::ActionBarInput* self = (EmberOgre::Gui::ActionBarInput*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Icons__IconManager (lua_State* tolua_S)
{
 EmberOgre::Gui::Icons::IconManager* self = (EmberOgre::Gui::Icons::IconManager*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Vector3Adapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Vector3Adapter* self = (EmberOgre::Gui::Vector3Adapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_std__vector_EmberOgre__EntityPickResult_ (lua_State* tolua_S)
{
 std::vector<EmberOgre::EntityPickResult>* self = (std::vector<EmberOgre::EntityPickResult>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__ActionBarIconDragDropTarget (lua_State* tolua_S)
{
 EmberOgre::Gui::ActionBarIconDragDropTarget* self = (EmberOgre::Gui::ActionBarIconDragDropTarget*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__ActionBarIconManager__AvatarIdType (lua_State* tolua_S)
{
 EmberOgre::Gui::ActionBarIconManager::AvatarIdType* self = (EmberOgre::Gui::ActionBarIconManager::AvatarIdType*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_WFMath__Quaternion (lua_State* tolua_S)
{
 WFMath::Quaternion* self = (WFMath::Quaternion*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Terrain__TerrainLayerDefinitionManager__DefinitionStore__const_iterator (lua_State* tolua_S)
{
 EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator* self = (EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__OverlayCompassImpl (lua_State* tolua_S)
{
 EmberOgre::Gui::OverlayCompassImpl* self = (EmberOgre::Gui::OverlayCompassImpl*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__QuaternionAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::QuaternionAdapter* self = (EmberOgre::Gui::QuaternionAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Ogre__Real (lua_State* tolua_S)
{
 Ogre::Real* self = (Ogre::Real*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_WFMath__Vector_3_ (lua_State* tolua_S)
{
 WFMath::Vector<3>* self = (WFMath::Vector<3>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_std__vector_Eris__Task__ (lua_State* tolua_S)
{
 std::vector<Eris::Task*>* self = (std::vector<Eris::Task*>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__EntityIconDragDropTarget (lua_State* tolua_S)
{
 EmberOgre::Gui::EntityIconDragDropTarget* self = (EmberOgre::Gui::EntityIconDragDropTarget*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Atlas__Message__MapType (lua_State* tolua_S)
{
 Atlas::Message::MapType* self = (Atlas::Message::MapType*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Ogre__Quaternion (lua_State* tolua_S)
{
 Ogre::Quaternion* self = (Ogre::Quaternion*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_WFMath__Point_2_ (lua_State* tolua_S)
{
 WFMath::Point<2>* self = (WFMath::Point<2>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Ogre__TexturePtr (lua_State* tolua_S)
{
 Ogre::TexturePtr* self = (Ogre::TexturePtr*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Model__ModelDefinitionAtlasComposer (lua_State* tolua_S)
{
 EmberOgre::Model::ModelDefinitionAtlasComposer* self = (EmberOgre::Model::ModelDefinitionAtlasComposer*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__EntityCreator (lua_State* tolua_S)
{
 EmberOgre::Gui::EntityCreator* self = (EmberOgre::Gui::EntityCreator*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Ogre__ResourcePtr (lua_State* tolua_S)
{
 Ogre::ResourcePtr* self = (Ogre::ResourcePtr*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Authoring__GUIAdaptersStore__const_iterator (lua_State* tolua_S)
{
 EmberOgre::Authoring::GUIAdaptersStore::const_iterator* self = (EmberOgre::Authoring::GUIAdaptersStore::const_iterator*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__ModelRenderer (lua_State* tolua_S)
{
 EmberOgre::Gui::ModelRenderer* self = (EmberOgre::Gui::ModelRenderer*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Ogre__Vector2 (lua_State* tolua_S)
{
 Ogre::Vector2* self = (Ogre::Vector2*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Compass (lua_State* tolua_S)
{
 EmberOgre::Gui::Compass* self = (EmberOgre::Gui::Compass*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__ListHolder (lua_State* tolua_S)
{
 EmberOgre::Gui::ListHolder* self = (EmberOgre::Gui::ListHolder*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Authoring__GUIAdapter (lua_State* tolua_S)
{
 EmberOgre::Authoring::GUIAdapter* self = (EmberOgre::Authoring::GUIAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Authoring__AtlasObjectDecoder (lua_State* tolua_S)
{
 EmberOgre::Authoring::AtlasObjectDecoder* self = (EmberOgre::Authoring::AtlasObjectDecoder*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Ogre__Vector3 (lua_State* tolua_S)
{
 Ogre::Vector3* self = (Ogre::Vector3*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__QuickHelpCursor (lua_State* tolua_S)
{
 EmberOgre::Gui::QuickHelpCursor* self = (EmberOgre::Gui::QuickHelpCursor*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Model__ModelDefnPtr (lua_State* tolua_S)
{
 EmberOgre::Model::ModelDefnPtr* self = (EmberOgre::Model::ModelDefnPtr*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__CompassThirdPersonCameraAnchor (lua_State* tolua_S)
{
 EmberOgre::Gui::CompassThirdPersonCameraAnchor* self = (EmberOgre::Gui::CompassThirdPersonCameraAnchor*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__HelpMessage (lua_State* tolua_S)
{
 EmberOgre::Gui::HelpMessage* self = (EmberOgre::Gui::HelpMessage*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__StackableContainer (lua_State* tolua_S)
{
 EmberOgre::Gui::StackableContainer* self = (EmberOgre::Gui::StackableContainer*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__CEGUICompassImpl (lua_State* tolua_S)
{
 EmberOgre::Gui::CEGUICompassImpl* self = (EmberOgre::Gui::CEGUICompassImpl*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"std::vector<EmberOgre::Model::SubModelDefinition*>");
 tolua_usertype(tolua_S,"EmberOgre::Authoring::EntityMover");
 tolua_usertype(tolua_S,"std::set<std::string>");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter");
 tolua_usertype(tolua_S,"EmberOgre::Camera::MainCamera");
 tolua_usertype(tolua_S,"EmberOgre::Gui::RenderedCompassImpl");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainMod");
 tolua_usertype(tolua_S,"CEGUI::TreeItem");
 tolua_usertype(tolua_S,"Ogre::SceneManager");
 tolua_usertype(tolua_S,"EmberOgre::SimpleRenderContext");
 tolua_usertype(tolua_S,"Atlas::Objects::Root");
 tolua_usertype(tolua_S,"Mercator::BasePoint");
 tolua_usertype(tolua_S,"Ogre::Degree");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>");
 tolua_usertype(tolua_S,"std::vector<EmberOgre::Model::ActionDefinition*>");
 tolua_usertype(tolua_S,"EmberOgre::IGraphicalRepresentation");
 tolua_usertype(tolua_S,"EmberOgre::Gui::EntityEditor");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainManager");
 tolua_usertype(tolua_S,"EmberOgre::Gui::CompassCameraAnchor");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainEditorOverlay");
 tolua_usertype(tolua_S,"virtual sigc::trackable");
 tolua_usertype(tolua_S,"EmberOgre::MovableObjectRenderer");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::BasePointUserObject");
 tolua_usertype(tolua_S,"CEGUI::UVector2");
 tolua_usertype(tolua_S,"EmberOgre::Gui::ICompassImpl");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainArea");
 tolua_usertype(tolua_S,"EmberOgre::Gui::AssetsManager");
 tolua_usertype(tolua_S,"sigc::signal<void,const EmberOgre::Terrain::TerrainEditAction*>");
 tolua_usertype(tolua_S,"Ogre::TRect<float>");
 tolua_usertype(tolua_S,"EmberOgre::Gui::EntityIconSlot");
 tolua_usertype(tolua_S,"EmberOgre::Gui::CompassSceneNodeAnchor");
 tolua_usertype(tolua_S,"EmberOgre::Gui::TexturePair");
 tolua_usertype(tolua_S,"EmberOgre::Gui::EntityIconDragDropPreview");
 tolua_usertype(tolua_S,"CEGUI::Tooltip");
 tolua_usertype(tolua_S,"Atlas::Message::Element");
 tolua_usertype(tolua_S,"std::vector<EmberOgre::Terrain::TerrainEditBasePointMovement>");
 tolua_usertype(tolua_S,"WFMath::Point<3>");
 tolua_usertype(tolua_S,"EmberOgre::Authoring::EntityRecipePtr");
 tolua_usertype(tolua_S,"std::iostream");
 tolua_usertype(tolua_S,"EmberOgre::Gui::IconBar");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainLayerDefinition");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter");
 tolua_usertype(tolua_S,"Eris::TypeService");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::Terrain::BasePointUserObject*>");
 tolua_usertype(tolua_S,"Ogre::AxisAlignedBox");
 tolua_usertype(tolua_S,"EmberOgre::Gui::EntityIconManager");
 tolua_usertype(tolua_S,"WFMath::Point<2>");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Icons::IconManager");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::Terrain::TerrainManager&>");
 tolua_usertype(tolua_S,"sigc::signal<void,float>");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::MotionManager&>");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::GUIManager&>");
 tolua_usertype(tolua_S,"EmberOgre::Environment::ISun");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::EmberEntity&>");
 tolua_usertype(tolua_S,"std::vector<EmberOgre::EntityPickResult>");
 tolua_usertype(tolua_S,"EmberOgre::Gui::ActionBarIcon");
 tolua_usertype(tolua_S,"Ember::ConsoleCommandWrapper");
 tolua_usertype(tolua_S,"EmberOgre::Gui::ActionBarIconDragDropTarget");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::EmberEntityFactory&>");
 tolua_usertype(tolua_S,"Ogre::RenderWindow");
 tolua_usertype(tolua_S,"EmberOgre::Gui::EntityTooltip");
 tolua_usertype(tolua_S,"EmberOgre::Scene");
 tolua_usertype(tolua_S,"Eris::View");
 tolua_usertype(tolua_S,"EmberOgre::World");
 tolua_usertype(tolua_S,"EmberOgre::Model::ModelDefinition");
 tolua_usertype(tolua_S,"WFMath::Quaternion");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::Terrain::TerrainEditorOverlay&>");
 tolua_usertype(tolua_S,"EmberOgre::Authoring::AuthoringManager");
 tolua_usertype(tolua_S,"Ember::Singleton<EntityRecipeManager>");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore");
 tolua_usertype(tolua_S,"EmberOgre::Environment::IFog");
 tolua_usertype(tolua_S,"EmberOgre::Model::AttachPointDefinition");
 tolua_usertype(tolua_S,"Atlas::Message::MapType");
 tolua_usertype(tolua_S,"Mercator::Area");
 tolua_usertype(tolua_S,"sigc::signal<void,const std::string&,EmberOgre::EmberEntity*>");
 tolua_usertype(tolua_S,"EmberOgre::Avatar");
 tolua_usertype(tolua_S,"Ogre::SceneNode");
 tolua_usertype(tolua_S,"EmberOgre::OgreInfo");
 tolua_usertype(tolua_S,"EmberOgre::Model::SubModelDefinition");
 tolua_usertype(tolua_S,"Ogre::ResourceHandle");
 tolua_usertype(tolua_S,"Eris::Entity");
 tolua_usertype(tolua_S,"EmberOgre::Gui::QuickHelp");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Compass");
 tolua_usertype(tolua_S,"sigc::signal<void,const std::string&>");
 tolua_usertype(tolua_S,"EmberOgre::EmberEntityFactory");
 tolua_usertype(tolua_S,"Ogre::Entity");
 tolua_usertype(tolua_S,"Ogre::Vector3");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::Map");
 tolua_usertype(tolua_S,"EmberOgre::Gui::QuaternionAdapter");
 tolua_usertype(tolua_S,"EmberOgre::Gui::CompassThirdPersonCameraAnchor");
 tolua_usertype(tolua_S,"Ogre::Sphere");
 tolua_usertype(tolua_S,"Eris::Task");
 tolua_usertype(tolua_S,"sigc::signal<void,const Ogre::ColourValue&>");
 tolua_usertype(tolua_S,"std::vector<Eris::Task*>");
 tolua_usertype(tolua_S,"std::vector<EmberOgre::Model::SubEntityDefinition*>");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Widget");
 tolua_usertype(tolua_S,"EmberOgre::MovementController");
 tolua_usertype(tolua_S,"EmberOgre::MovementControllerMode");
 tolua_usertype(tolua_S,"Ogre::Resource");
 tolua_usertype(tolua_S,"WFMath::Vector<3>");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Icons::Icon");
 tolua_usertype(tolua_S,"std::vector<std::string>");
 tolua_usertype(tolua_S,"Ogre::Radian");
 tolua_usertype(tolua_S,"CEGUI::Editbox");
 tolua_usertype(tolua_S,"EmberOgre::Gui::ActionBarIconSlot");
 tolua_usertype(tolua_S,"sigc::signal<void,const Atlas::Objects::Root&>");
 tolua_usertype(tolua_S,"EmberOgre::Model::ModelDefnPtr");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainPage");
 tolua_usertype(tolua_S,"EmberOgre::Authoring::AtlasObjectDecoder");
 tolua_usertype(tolua_S,"EmberOgre::Authoring::RawTypeInfoRepository");
 tolua_usertype(tolua_S,"EmberOgre::Gui::OverlayCompassImpl");
 tolua_usertype(tolua_S,"EmberOgre::Gui::ActionBarIconManager");
 tolua_usertype(tolua_S,"EmberOgre::Model::PartDefinition");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::ISceneManagerAdapter");
 tolua_usertype(tolua_S,"Ogre::DataStreamPtr");
 tolua_usertype(tolua_S,"Ogre::Viewport");
 tolua_usertype(tolua_S,"size_t");
 tolua_usertype(tolua_S,"EmberOgre::Authoring::GUIAdaptersStore::const_iterator");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainLayerDefinitionManager");
 tolua_usertype(tolua_S,"Ogre::ResourcePtr");
 tolua_usertype(tolua_S,"EmberOgre::Authoring::EntityRecipeManager");
 tolua_usertype(tolua_S,"EmberOgre::Authoring::GUIAdaptersStore::value_type");
 tolua_usertype(tolua_S,"CEGUI::ListboxItem");
 tolua_usertype(tolua_S,"CEGUI::Imageset");
 tolua_usertype(tolua_S,"EmberOgre::Authoring::GUIAdaptersStore");
 tolua_usertype(tolua_S,"EmberOgre::Model::Model");
 tolua_usertype(tolua_S,"EmberOgre::MousePickerArgs");
 tolua_usertype(tolua_S,"EmberOgre::Gui::ConsoleAdapter");
 tolua_usertype(tolua_S,"Ogre::ManualResourceLoader");
 tolua_usertype(tolua_S,"EmberOgre::Gui::QuickHelpCursor");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::MapView");
 tolua_usertype(tolua_S,"sigc::signal<void,Ogre::Camera&>");
 tolua_usertype(tolua_S,"std::vector<EmberOgre::Model::AttachPointDefinition>");
 tolua_usertype(tolua_S,"EmberOgre::Environment::ISky");
 tolua_usertype(tolua_S,"EmberOgre::Gui::IconBase");
 tolua_usertype(tolua_S,"Ogre::String");
 tolua_usertype(tolua_S,"EmberOgre::Authoring::EntityRecipe");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainShader");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::EmberEntity&,EmberOgre::Authoring::EntityMover&>");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::MovementControllerMode::Mode>");
 tolua_usertype(tolua_S,"CEGUI::Tree");
 tolua_usertype(tolua_S,"EmberOgre::Authoring::EntityMoveManager");
 tolua_usertype(tolua_S,"EmberOgre::Model::ModelDefinitionAtlasComposer");
 tolua_usertype(tolua_S,"EmberOgre::Model::ModelDefinitionManager");
 tolua_usertype(tolua_S,"sigc::signal<void,const std::vector<EmberOgre::EntityPickResult>&,const EmberOgre::MousePickerArgs&>");
 tolua_usertype(tolua_S,"EmberOgre::Model::SubEntityDefinition");
 tolua_usertype(tolua_S,"EmberOgre::EntityWorldPickListener");
 tolua_usertype(tolua_S,"EmberOgre::Model::SubModel");
 tolua_usertype(tolua_S,"EmberOgre::GUIManager");
 tolua_usertype(tolua_S,"EmberOgre::Gui::ListHolder");
 tolua_usertype(tolua_S,"EmberOgre::Gui::ModelRenderer");
 tolua_usertype(tolua_S,"EmberOgre::Gui::OgreEntityRenderer");
 tolua_usertype(tolua_S,"EmberOgre::Gui::MovableObjectRenderer");
 tolua_usertype(tolua_S,"Ogre::Light");
 tolua_usertype(tolua_S,"Ogre::MovableObject");
 tolua_usertype(tolua_S,"Ogre::RenderTexture");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainEditor");
 tolua_usertype(tolua_S,"EmberOgre::Environment::IWater");
 tolua_usertype(tolua_S,"EmberOgre::EmberEntity");
 tolua_usertype(tolua_S,"EmberOgre::Model::ModelRepresentation");
 tolua_usertype(tolua_S,"WFMath::Vector<2>");
 tolua_usertype(tolua_S,"Ogre::Vector2");
 tolua_usertype(tolua_S,"EmberOgre::Convert");
 tolua_usertype(tolua_S,"EmberOgre::TerrainPosition");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainPageSurfaceLayer");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::Terrain::TerrainPage&>");
 tolua_usertype(tolua_S,"Atlas::Objects::ObjectsDecoder");
 tolua_usertype(tolua_S,"std::map<std::string,EmberOgre::Model::ViewDefinition*>");
 tolua_usertype(tolua_S,"EmberOgre::Model::ActionDefinition");
 tolua_usertype(tolua_S,"std::vector<EmberOgre::Model::PartDefinition*>");
 tolua_usertype(tolua_S,"EmberOgre::Gui::HelpMessage");
 tolua_usertype(tolua_S,"EmberOgre::EntityPickResult");
 tolua_usertype(tolua_S,"CEGUI::PushButton");
 tolua_usertype(tolua_S,"EmberOgre::Model::ModelRepresentationManager");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Vector3Adapter");
 tolua_usertype(tolua_S,"Ogre::MeshPtr");
 tolua_usertype(tolua_S,"EmberOgre::Model::Action");
 tolua_usertype(tolua_S,"sigc::signal<void,const EmberOgre::Gui::HelpMessage&>");
 tolua_usertype(tolua_S,"CEGUI::Image");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::MapAdapter");
 tolua_usertype(tolua_S,"Ember::Singleton<EmberOgre::Authoring::EntityRecipeManager>");
 tolua_usertype(tolua_S,"CEGUI::Listbox");
 tolua_usertype(tolua_S,"EmberOgre::Gui::ActionBarIconManager::AvatarIdType");
 tolua_usertype(tolua_S,"EmberOgre::Environment::Foliage");
 tolua_usertype(tolua_S,"EmberOgre::IAnimated");
 tolua_usertype(tolua_S,"CEGUI::ListboxTextItem");
 tolua_usertype(tolua_S,"Ogre::TexturePtr");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>");
 tolua_usertype(tolua_S,"EmberOgre::EmberOgre");
 tolua_usertype(tolua_S,"EmberOgre::Gui::AtlasHelper");
 tolua_usertype(tolua_S,"Eris::ServerInfo");
 tolua_usertype(tolua_S,"EmberOgre::Gui::ActionBarInput");
 tolua_usertype(tolua_S,"EmberOgre::Model::ViewDefinition");
 tolua_usertype(tolua_S,"Ogre::ResourceManager");
 tolua_usertype(tolua_S,"EmberOgre::Gui::EntityIconDragDropTarget");
 tolua_usertype(tolua_S,"CEGUI::DragContainer");
 tolua_usertype(tolua_S,"Ogre::Real");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::EmberEntity*>");
 tolua_usertype(tolua_S,"EmberOgre::Gui::EntityIcon");
 tolua_usertype(tolua_S,"sigc::signal<void,EmberOgre::World&>");
 tolua_usertype(tolua_S,"EmberOgre::MotionManager::MotionManagerInfo");
 tolua_usertype(tolua_S,"Ogre::Quaternion");
 tolua_usertype(tolua_S,"Eris::TypeInfo");
 tolua_usertype(tolua_S,"Ogre::Camera");
 tolua_usertype(tolua_S,"Ogre::MaterialPtr");
 tolua_usertype(tolua_S,"EmberOgre::Gui::EntityCreator");
 tolua_usertype(tolua_S,"CEGUI::Window");
 tolua_usertype(tolua_S,"EmberOgre::Gui::StackableContainer");
 tolua_usertype(tolua_S,"std::ostream");
 tolua_usertype(tolua_S,"Ogre::ColourValue");
 tolua_usertype(tolua_S,"Ogre::NameValuePairList");
 tolua_usertype(tolua_S,"EmberOgre::Environment::Environment");
 tolua_usertype(tolua_S,"EmberOgre::Authoring::GUIAdapter");
 tolua_usertype(tolua_S,"EmberOgre::Gui::ColouredTreeItem");
 tolua_usertype(tolua_S,"EmberOgre::WorldEmberEntity");
 tolua_usertype(tolua_S,"EmberOgre::MotionManager");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainEditAction");
 tolua_usertype(tolua_S,"sigc::signal<void>");
 tolua_usertype(tolua_S,"EmberOgre::Gui::ColouredListItem");
 tolua_usertype(tolua_S,"EmberOgre::Terrain::TerrainEditBasePointMovement");
 tolua_usertype(tolua_S,"EmberOgre::Gui::CEGUICompassImpl");
}

/* method: getCamera of class  EmberOgre::Camera::MainCamera */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Camera_MainCamera_getCamera00
static int tolua_EmberOgre_EmberOgre_Camera_MainCamera_getCamera00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Camera::MainCamera",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Camera::MainCamera* self = (const EmberOgre::Camera::MainCamera*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCamera'", NULL);
#endif
  {
   Ogre::Camera& tolua_ret = (Ogre::Camera&)  self->getCamera();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ogre::Camera");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCamera'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOrientation of class  EmberOgre::Camera::MainCamera */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Camera_MainCamera_getOrientation00
static int tolua_EmberOgre_EmberOgre_Camera_MainCamera_getOrientation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Camera::MainCamera",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Camera::MainCamera* self = (const EmberOgre::Camera::MainCamera*)  tolua_tousertype(tolua_S,1,0);
  bool onlyHorizontal = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOrientation'", NULL);
#endif
  {
   const Ogre::Quaternion& tolua_ret = (const Ogre::Quaternion&)  self->getOrientation(onlyHorizontal);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Ogre::Quaternion");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOrientation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPosition of class  EmberOgre::Camera::MainCamera */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Camera_MainCamera_getPosition00
static int tolua_EmberOgre_EmberOgre_Camera_MainCamera_getPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Camera::MainCamera",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Camera::MainCamera* self = (const EmberOgre::Camera::MainCamera*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPosition'", NULL);
#endif
  {
   const Ogre::Vector3& tolua_ret = (const Ogre::Vector3&)  self->getPosition();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Ogre::Vector3");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: MovedCamera of class  EmberOgre::Camera::MainCamera */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Camera__MainCamera_MovedCamera
static int tolua_get_EmberOgre__Camera__MainCamera_MovedCamera(lua_State* tolua_S)
{
  EmberOgre::Camera::MainCamera* self = (EmberOgre::Camera::MainCamera*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MovedCamera'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->MovedCamera,"sigc::signal<void,Ogre::Camera&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: MovedCamera of class  EmberOgre::Camera::MainCamera */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Camera__MainCamera_MovedCamera
static int tolua_set_EmberOgre__Camera__MainCamera_MovedCamera(lua_State* tolua_S)
{
  EmberOgre::Camera::MainCamera* self = (EmberOgre::Camera::MainCamera*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MovedCamera'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,Ogre::Camera&>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->MovedCamera = *((sigc::signal<void,Ogre::Camera&>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: setClosestPickingDistance of class  EmberOgre::Camera::MainCamera */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Camera_MainCamera_setClosestPickingDistance00
static int tolua_EmberOgre_EmberOgre_Camera_MainCamera_setClosestPickingDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Camera::MainCamera",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Camera::MainCamera* self = (EmberOgre::Camera::MainCamera*)  tolua_tousertype(tolua_S,1,0);
  float distance = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setClosestPickingDistance'", NULL);
#endif
  {
   self->setClosestPickingDistance(distance);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setClosestPickingDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getClosestPickingDistance of class  EmberOgre::Camera::MainCamera */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Camera_MainCamera_getClosestPickingDistance00
static int tolua_EmberOgre_EmberOgre_Camera_MainCamera_getClosestPickingDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Camera::MainCamera",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Camera::MainCamera* self = (const EmberOgre::Camera::MainCamera*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getClosestPickingDistance'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getClosestPickingDistance();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getClosestPickingDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: enableCompositor of class  EmberOgre::Camera::MainCamera */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Camera_MainCamera_enableCompositor00
static int tolua_EmberOgre_EmberOgre_Camera_MainCamera_enableCompositor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Camera::MainCamera",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Camera::MainCamera* self = (EmberOgre::Camera::MainCamera*)  tolua_tousertype(tolua_S,1,0);
  const std::string compositorName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  bool enable = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'enableCompositor'", NULL);
#endif
  {
   self->enableCompositor(compositorName,enable);
   tolua_pushcppstring(tolua_S,(const char*)compositorName);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'enableCompositor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toggleRenderMode of class  EmberOgre::Camera::MainCamera */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Camera_MainCamera_toggleRenderMode00
static int tolua_EmberOgre_EmberOgre_Camera_MainCamera_toggleRenderMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Camera::MainCamera",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Camera::MainCamera* self = (EmberOgre::Camera::MainCamera*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toggleRenderMode'", NULL);
#endif
  {
   self->toggleRenderMode();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toggleRenderMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: takeScreenshot of class  EmberOgre::Camera::MainCamera */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Camera_MainCamera_takeScreenshot00
static int tolua_EmberOgre_EmberOgre_Camera_MainCamera_takeScreenshot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Camera::MainCamera",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Camera::MainCamera* self = (EmberOgre::Camera::MainCamera*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'takeScreenshot'", NULL);
#endif
  {
   self->takeScreenshot();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'takeScreenshot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventMovementModeChanged of class  EmberOgre::MovementController */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__MovementController_EventMovementModeChanged
static int tolua_get_EmberOgre__MovementController_EventMovementModeChanged(lua_State* tolua_S)
{
  EmberOgre::MovementController* self = (EmberOgre::MovementController*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMovementModeChanged'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventMovementModeChanged,"sigc::signal<void,EmberOgre::MovementControllerMode::Mode>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventMovementModeChanged of class  EmberOgre::MovementController */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__MovementController_EventMovementModeChanged
static int tolua_set_EmberOgre__MovementController_EventMovementModeChanged(lua_State* tolua_S)
{
  EmberOgre::MovementController* self = (EmberOgre::MovementController*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMovementModeChanged'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::MovementControllerMode::Mode>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventMovementModeChanged = *((sigc::signal<void,EmberOgre::MovementControllerMode::Mode>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveToPoint of class  EmberOgre::MovementController */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_MovementController_moveToPoint00
static int tolua_EmberOgre_EmberOgre_MovementController_moveToPoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::MovementController",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Vector3",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::MovementController* self = (EmberOgre::MovementController*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::Vector3* point = ((const Ogre::Vector3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveToPoint'", NULL);
#endif
  {
   self->moveToPoint(*point);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveToPoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: teleportTo of class  EmberOgre::MovementController */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_MovementController_teleportTo00
static int tolua_EmberOgre_EmberOgre_MovementController_teleportTo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::MovementController",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Vector3",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::MovementController* self = (EmberOgre::MovementController*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::Vector3* point = ((const Ogre::Vector3*)  tolua_tousertype(tolua_S,2,0));
  EmberOgre::EmberEntity* locationEntity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'teleportTo'", NULL);
#endif
  {
   self->teleportTo(*point,locationEntity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'teleportTo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMode of class  EmberOgre::MovementController */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_MovementController_getMode00
static int tolua_EmberOgre_EmberOgre_MovementController_getMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::MovementController",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::MovementController* self = (const EmberOgre::MovementController*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMode'", NULL);
#endif
  {
   EmberOgre::MovementControllerMode::Mode tolua_ret = (EmberOgre::MovementControllerMode::Mode)  self->getMode();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAvatarSceneNode of class  EmberOgre::Avatar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Avatar_getAvatarSceneNode00
static int tolua_EmberOgre_EmberOgre_Avatar_getAvatarSceneNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Avatar",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Avatar* self = (const EmberOgre::Avatar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAvatarSceneNode'", NULL);
#endif
  {
   Ogre::SceneNode* tolua_ret = (Ogre::SceneNode*)  self->getAvatarSceneNode();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ogre::SceneNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAvatarSceneNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEmberEntity of class  EmberOgre::Avatar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Avatar_getEmberEntity00
static int tolua_EmberOgre_EmberOgre_Avatar_getEmberEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Avatar",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Avatar* self = (EmberOgre::Avatar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEmberEntity'", NULL);
#endif
  {
   EmberOgre::EmberEntity& tolua_ret = (EmberOgre::EmberEntity&)  self->getEmberEntity();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::EmberEntity");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEmberEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMinIntervalOfRotationChanges of class  EmberOgre::Avatar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Avatar_setMinIntervalOfRotationChanges00
static int tolua_EmberOgre_EmberOgre_Avatar_setMinIntervalOfRotationChanges00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Avatar",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::Real",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Avatar* self = (EmberOgre::Avatar*)  tolua_tousertype(tolua_S,1,0);
  Ogre::Real milliseconds = *((Ogre::Real*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMinIntervalOfRotationChanges'", NULL);
#endif
  {
   self->setMinIntervalOfRotationChanges(milliseconds);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMinIntervalOfRotationChanges'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventAddedEntityToInventory of class  EmberOgre::Avatar */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Avatar_EventAddedEntityToInventory
static int tolua_get_EmberOgre__Avatar_EventAddedEntityToInventory(lua_State* tolua_S)
{
  EmberOgre::Avatar* self = (EmberOgre::Avatar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventAddedEntityToInventory'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventAddedEntityToInventory,"sigc::signal<void,EmberOgre::EmberEntity*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventAddedEntityToInventory of class  EmberOgre::Avatar */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Avatar_EventAddedEntityToInventory
static int tolua_set_EmberOgre__Avatar_EventAddedEntityToInventory(lua_State* tolua_S)
{
  EmberOgre::Avatar* self = (EmberOgre::Avatar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventAddedEntityToInventory'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::EmberEntity*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventAddedEntityToInventory = *((sigc::signal<void,EmberOgre::EmberEntity*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventRemovedEntityFromInventory of class  EmberOgre::Avatar */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Avatar_EventRemovedEntityFromInventory
static int tolua_get_EmberOgre__Avatar_EventRemovedEntityFromInventory(lua_State* tolua_S)
{
  EmberOgre::Avatar* self = (EmberOgre::Avatar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventRemovedEntityFromInventory'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventRemovedEntityFromInventory,"sigc::signal<void,EmberOgre::EmberEntity*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventRemovedEntityFromInventory of class  EmberOgre::Avatar */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Avatar_EventRemovedEntityFromInventory
static int tolua_set_EmberOgre__Avatar_EventRemovedEntityFromInventory(lua_State* tolua_S)
{
  EmberOgre::Avatar* self = (EmberOgre::Avatar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventRemovedEntityFromInventory'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::EmberEntity*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventRemovedEntityFromInventory = *((sigc::signal<void,EmberOgre::EmberEntity*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: isAdmin of class  EmberOgre::Avatar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Avatar_isAdmin00
static int tolua_EmberOgre_EmberOgre_Avatar_isAdmin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Avatar",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Avatar* self = (const EmberOgre::Avatar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isAdmin'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isAdmin();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isAdmin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getClientSideAvatarPosition of class  EmberOgre::Avatar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Avatar_getClientSideAvatarPosition00
static int tolua_EmberOgre_EmberOgre_Avatar_getClientSideAvatarPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Avatar",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Avatar* self = (const EmberOgre::Avatar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getClientSideAvatarPosition'", NULL);
#endif
  {
   WFMath::Point<3> tolua_ret = (WFMath::Point<3>)  self->getClientSideAvatarPosition();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((WFMath::Point<3>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Point<3>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(WFMath::Point<3>));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Point<3>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getClientSideAvatarPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getClientSideAvatarOrientation of class  EmberOgre::Avatar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Avatar_getClientSideAvatarOrientation00
static int tolua_EmberOgre_EmberOgre_Avatar_getClientSideAvatarOrientation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Avatar",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Avatar* self = (const EmberOgre::Avatar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getClientSideAvatarOrientation'", NULL);
#endif
  {
   WFMath::Quaternion tolua_ret = (WFMath::Quaternion)  self->getClientSideAvatarOrientation();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((WFMath::Quaternion)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Quaternion");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(WFMath::Quaternion));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Quaternion");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getClientSideAvatarOrientation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWorld of class  EmberOgre::EmberEntityFactory */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntityFactory_getWorld00
static int tolua_EmberOgre_EmberOgre_EmberEntityFactory_getWorld00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::EmberEntityFactory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::EmberEntityFactory* self = (const EmberOgre::EmberEntityFactory*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWorld'", NULL);
#endif
  {
   EmberOgre::WorldEmberEntity* tolua_ret = (EmberOgre::WorldEmberEntity*)  self->getWorld();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::WorldEmberEntity");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWorld'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: dumpAttributesOfEntity of class  EmberOgre::EmberEntityFactory */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntityFactory_dumpAttributesOfEntity00
static int tolua_EmberOgre_EmberOgre_EmberEntityFactory_dumpAttributesOfEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::EmberEntityFactory",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::EmberEntityFactory* self = (const EmberOgre::EmberEntityFactory*)  tolua_tousertype(tolua_S,1,0);
  const std::string entityId = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dumpAttributesOfEntity'", NULL);
#endif
  {
   self->dumpAttributesOfEntity(entityId);
   tolua_pushcppstring(tolua_S,(const char*)entityId);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'dumpAttributesOfEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hasSuggestedResponses of class  EmberOgre::EmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntity_hasSuggestedResponses00
static int tolua_EmberOgre_EmberOgre_EmberEntity_hasSuggestedResponses00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::EmberEntity* self = (const EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hasSuggestedResponses'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->hasSuggestedResponses();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hasSuggestedResponses'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSuggestedResponses of class  EmberOgre::EmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntity_getSuggestedResponses00
static int tolua_EmberOgre_EmberOgre_EmberEntity_getSuggestedResponses00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::EmberEntity* self = (const EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSuggestedResponses'", NULL);
#endif
  {
   const std::vector<std::string>& tolua_ret = (const std::vector<std::string>&)  self->getSuggestedResponses();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const std::vector<std::string>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSuggestedResponses'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEmberLocation of class  EmberOgre::EmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntity_getEmberLocation00
static int tolua_EmberOgre_EmberOgre_EmberEntity_getEmberLocation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::EmberEntity* self = (const EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEmberLocation'", NULL);
#endif
  {
   EmberOgre::EmberEntity* tolua_ret = (EmberOgre::EmberEntity*)  self->getEmberLocation();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::EmberEntity");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEmberLocation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isInitialized of class  EmberOgre::EmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntity_isInitialized00
static int tolua_EmberOgre_EmberOgre_EmberEntity_isInitialized00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::EmberEntity* self = (const EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isInitialized'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isInitialized();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isInitialized'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPositioningMode of class  EmberOgre::EmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntity_getPositioningMode00
static int tolua_EmberOgre_EmberOgre_EmberEntity_getPositioningMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::EmberEntity* self = (const EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPositioningMode'", NULL);
#endif
  {
   EmberOgre::EmberEntity::PositioningMode tolua_ret = (EmberOgre::EmberEntity::PositioningMode)  self->getPositioningMode();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPositioningMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultUseOperators of class  EmberOgre::EmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntity_getDefaultUseOperators00
static int tolua_EmberOgre_EmberOgre_EmberEntity_getDefaultUseOperators00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::EmberEntity* self = (EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefaultUseOperators'", NULL);
#endif
  {
   std::vector<std::string> tolua_ret = (std::vector<std::string>)  self->getDefaultUseOperators();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<std::string>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<std::string>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultUseOperators'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getActions of class  EmberOgre::EmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntity_getActions00
static int tolua_EmberOgre_EmberOgre_EmberEntity_getActions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::EmberEntity* self = (EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getActions'", NULL);
#endif
  {
   std::vector<std::string> tolua_ret = (std::vector<std::string>)  self->getActions();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<std::string>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<std::string>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getActions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVisualize of class  EmberOgre::EmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntity_setVisualize00
static int tolua_EmberOgre_EmberOgre_EmberEntity_setVisualize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::EmberEntity* self = (EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,1,0);
  const std::string visualization = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  bool visualize = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVisualize'", NULL);
#endif
  {
   self->setVisualize(visualization,visualize);
   tolua_pushcppstring(tolua_S,(const char*)visualization);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVisualize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVisualize of class  EmberOgre::EmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntity_getVisualize00
static int tolua_EmberOgre_EmberOgre_EmberEntity_getVisualize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::EmberEntity* self = (const EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,1,0);
  const std::string visualization = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVisualize'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getVisualize(visualization);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)visualization);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVisualize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: dumpAttributes of class  EmberOgre::EmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntity_dumpAttributes00
static int tolua_EmberOgre_EmberOgre_EmberEntity_dumpAttributes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::EmberEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::iostream",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"std::ostream",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::EmberEntity* self = (const EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,1,0);
  std::iostream* outstream = ((std::iostream*)  tolua_tousertype(tolua_S,2,0));
  std::ostream* logOutstream = ((std::ostream*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dumpAttributes'", NULL);
#endif
  {
   self->dumpAttributes(*outstream,*logOutstream);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'dumpAttributes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAttachedEntity of class  EmberOgre::EmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberEntity_getAttachedEntity00
static int tolua_EmberOgre_EmberOgre_EmberEntity_getAttachedEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::EmberEntity* self = (EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,1,0);
  const std::string namedPoint = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAttachedEntity'", NULL);
#endif
  {
   EmberOgre::EmberEntity* tolua_ret = (EmberOgre::EmberEntity*)  self->getAttachedEntity(namedPoint);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::EmberEntity");
   tolua_pushcppstring(tolua_S,(const char*)namedPoint);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAttachedEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEnvironment of class  EmberOgre::WorldEmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_WorldEmberEntity_getEnvironment00
static int tolua_EmberOgre_EmberOgre_WorldEmberEntity_getEnvironment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::WorldEmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::WorldEmberEntity* self = (const EmberOgre::WorldEmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEnvironment'", NULL);
#endif
  {
   EmberOgre::Environment::Environment* tolua_ret = (EmberOgre::Environment::Environment*)  self->getEnvironment();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Environment::Environment");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEnvironment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFoliage of class  EmberOgre::WorldEmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_WorldEmberEntity_getFoliage00
static int tolua_EmberOgre_EmberOgre_WorldEmberEntity_getFoliage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::WorldEmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::WorldEmberEntity* self = (const EmberOgre::WorldEmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFoliage'", NULL);
#endif
  {
   EmberOgre::Environment::Foliage* tolua_ret = (EmberOgre::Environment::Foliage*)  self->getFoliage();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Environment::Foliage");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFoliage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTerrainManager of class  EmberOgre::WorldEmberEntity */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_WorldEmberEntity_getTerrainManager00
static int tolua_EmberOgre_EmberOgre_WorldEmberEntity_getTerrainManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::WorldEmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::WorldEmberEntity* self = (EmberOgre::WorldEmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTerrainManager'", NULL);
#endif
  {
   EmberOgre::Terrain::TerrainManager& tolua_ret = (EmberOgre::Terrain::TerrainManager&)  self->getTerrainManager();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Terrain::TerrainManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTerrainManager'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventFoliageCreated of class  EmberOgre::WorldEmberEntity */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__WorldEmberEntity_EventFoliageCreated
static int tolua_get_EmberOgre__WorldEmberEntity_EventFoliageCreated(lua_State* tolua_S)
{
  EmberOgre::WorldEmberEntity* self = (EmberOgre::WorldEmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventFoliageCreated'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventFoliageCreated,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventFoliageCreated of class  EmberOgre::WorldEmberEntity */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__WorldEmberEntity_EventFoliageCreated
static int tolua_set_EmberOgre__WorldEmberEntity_EventFoliageCreated(lua_State* tolua_S)
{
  EmberOgre::WorldEmberEntity* self = (EmberOgre::WorldEmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventFoliageCreated'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventFoliageCreated = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventEnvironmentCreated of class  EmberOgre::WorldEmberEntity */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__WorldEmberEntity_EventEnvironmentCreated
static int tolua_get_EmberOgre__WorldEmberEntity_EventEnvironmentCreated(lua_State* tolua_S)
{
  EmberOgre::WorldEmberEntity* self = (EmberOgre::WorldEmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventEnvironmentCreated'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventEnvironmentCreated,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventEnvironmentCreated of class  EmberOgre::WorldEmberEntity */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__WorldEmberEntity_EventEnvironmentCreated
static int tolua_set_EmberOgre__WorldEmberEntity_EventEnvironmentCreated(lua_State* tolua_S)
{
  EmberOgre::WorldEmberEntity* self = (EmberOgre::WorldEmberEntity*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventEnvironmentCreated'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventEnvironmentCreated = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getType of class  EmberOgre::IGraphicalRepresentation */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_IGraphicalRepresentation_getType00
static int tolua_EmberOgre_EmberOgre_IGraphicalRepresentation_getType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::IGraphicalRepresentation",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::IGraphicalRepresentation* self = (const EmberOgre::IGraphicalRepresentation*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getType'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getType();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVisualize of class  EmberOgre::IGraphicalRepresentation */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_IGraphicalRepresentation_setVisualize00
static int tolua_EmberOgre_EmberOgre_IGraphicalRepresentation_setVisualize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::IGraphicalRepresentation",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::IGraphicalRepresentation* self = (EmberOgre::IGraphicalRepresentation*)  tolua_tousertype(tolua_S,1,0);
  const std::string visualization = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  bool visualize = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVisualize'", NULL);
#endif
  {
   self->setVisualize(visualization,visualize);
   tolua_pushcppstring(tolua_S,(const char*)visualization);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVisualize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVisualize of class  EmberOgre::IGraphicalRepresentation */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_IGraphicalRepresentation_getVisualize00
static int tolua_EmberOgre_EmberOgre_IGraphicalRepresentation_getVisualize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::IGraphicalRepresentation",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::IGraphicalRepresentation* self = (const EmberOgre::IGraphicalRepresentation*)  tolua_tousertype(tolua_S,1,0);
  const std::string visualization = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVisualize'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getVisualize(visualization);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)visualization);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVisualize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAmbientLight of class  EmberOgre::Environment::ISun */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Environment_ISun_setAmbientLight00
static int tolua_EmberOgre_EmberOgre_Environment_ISun_setAmbientLight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Environment::ISun",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::ColourValue",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Environment::ISun* self = (EmberOgre::Environment::ISun*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::ColourValue* colour = ((const Ogre::ColourValue*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAmbientLight'", NULL);
#endif
  {
   self->setAmbientLight(*colour);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAmbientLight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDensity of class  EmberOgre::Environment::IFog */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Environment_IFog_setDensity00
static int tolua_EmberOgre_EmberOgre_Environment_IFog_setDensity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Environment::IFog",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Environment::IFog* self = (EmberOgre::Environment::IFog*)  tolua_tousertype(tolua_S,1,0);
  float density = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDensity'", NULL);
#endif
  {
   self->setDensity(density);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDensity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDensity of class  EmberOgre::Environment::IFog */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Environment_IFog_getDensity00
static int tolua_EmberOgre_EmberOgre_Environment_IFog_getDensity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Environment::IFog",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Environment::IFog* self = (const EmberOgre::Environment::IFog*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDensity'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getDensity();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDensity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSun of class  EmberOgre::Environment::Environment */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Environment_Environment_getSun00
static int tolua_EmberOgre_EmberOgre_Environment_Environment_getSun00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Environment::Environment",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Environment::Environment* self = (EmberOgre::Environment::Environment*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSun'", NULL);
#endif
  {
   EmberOgre::Environment::ISun* tolua_ret = (EmberOgre::Environment::ISun*)  self->getSun();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Environment::ISun");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSun'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSky of class  EmberOgre::Environment::Environment */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Environment_Environment_getSky00
static int tolua_EmberOgre_EmberOgre_Environment_Environment_getSky00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Environment::Environment",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Environment::Environment* self = (EmberOgre::Environment::Environment*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSky'", NULL);
#endif
  {
   EmberOgre::Environment::ISky* tolua_ret = (EmberOgre::Environment::ISky*)  self->getSky();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Environment::ISky");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSky'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFog of class  EmberOgre::Environment::Environment */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Environment_Environment_getFog00
static int tolua_EmberOgre_EmberOgre_Environment_Environment_getFog00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Environment::Environment",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Environment::Environment* self = (EmberOgre::Environment::Environment*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFog'", NULL);
#endif
  {
   EmberOgre::Environment::IFog* tolua_ret = (EmberOgre::Environment::IFog*)  self->getFog();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Environment::IFog");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFog'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWater of class  EmberOgre::Environment::Environment */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Environment_Environment_getWater00
static int tolua_EmberOgre_EmberOgre_Environment_Environment_getWater00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Environment::Environment",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Environment::Environment* self = (EmberOgre::Environment::Environment*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWater'", NULL);
#endif
  {
   EmberOgre::Environment::IWater* tolua_ret = (EmberOgre::Environment::IWater*)  self->getWater();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Environment::IWater");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWater'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTime of class  EmberOgre::Environment::Environment */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Environment_Environment_setTime00
static int tolua_EmberOgre_EmberOgre_Environment_Environment_setTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Environment::Environment",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Environment::Environment* self = (EmberOgre::Environment::Environment*)  tolua_tousertype(tolua_S,1,0);
  int hour = ((int)  tolua_tonumber(tolua_S,2,0));
  int minute = ((int)  tolua_tonumber(tolua_S,3,0));
  int second = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTime'", NULL);
#endif
  {
   self->setTime(hour,minute,second);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTime of class  EmberOgre::Environment::Environment */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Environment_Environment_setTime01
static int tolua_EmberOgre_EmberOgre_Environment_Environment_setTime01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Environment::Environment",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::Environment::Environment* self = (EmberOgre::Environment::Environment*)  tolua_tousertype(tolua_S,1,0);
  int seconds = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTime'", NULL);
#endif
  {
   self->setTime(seconds);
  }
 }
 return 0;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Environment_Environment_setTime00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAmbientLight of class  EmberOgre::Environment::Environment */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Environment_Environment_setAmbientLight00
static int tolua_EmberOgre_EmberOgre_Environment_Environment_setAmbientLight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Environment::Environment",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::ColourValue",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Environment::Environment* self = (EmberOgre::Environment::Environment*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::ColourValue* colour = ((const Ogre::ColourValue*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAmbientLight'", NULL);
#endif
  {
   self->setAmbientLight(*colour);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAmbientLight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventUpdatedAmbientLight of class  EmberOgre::Environment::Environment */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Environment__Environment_EventUpdatedAmbientLight
static int tolua_get_EmberOgre__Environment__Environment_EventUpdatedAmbientLight(lua_State* tolua_S)
{
  EmberOgre::Environment::Environment* self = (EmberOgre::Environment::Environment*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventUpdatedAmbientLight'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventUpdatedAmbientLight,"sigc::signal<void,const Ogre::ColourValue&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_getSingleton00
static int tolua_EmberOgre_EmberOgre_GUIManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::GUIManager& tolua_ret = (EmberOgre::GUIManager&)  EmberOgre::GUIManager::getSingleton();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::GUIManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AppendIGChatLine of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__GUIManager_AppendIGChatLine
static int tolua_get_EmberOgre__GUIManager_AppendIGChatLine(lua_State* tolua_S)
{
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AppendIGChatLine'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->AppendIGChatLine,"sigc::signal<void,const std::string&,EmberOgre::EmberEntity*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AppendOOGChatLine of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__GUIManager_AppendOOGChatLine
static int tolua_get_EmberOgre__GUIManager_AppendOOGChatLine(lua_State* tolua_S)
{
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AppendOOGChatLine'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->AppendOOGChatLine,"sigc::signal<void,const std::string&,EmberOgre::EmberEntity*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AppendAvatarImaginary of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__GUIManager_AppendAvatarImaginary
static int tolua_get_EmberOgre__GUIManager_AppendAvatarImaginary(lua_State* tolua_S)
{
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AppendAvatarImaginary'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->AppendAvatarImaginary,"sigc::signal<void,const std::string&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventEntityAction of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__GUIManager_EventEntityAction
static int tolua_get_EmberOgre__GUIManager_EventEntityAction(lua_State* tolua_S)
{
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventEntityAction'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventEntityAction,"sigc::signal<void,const std::string&,EmberOgre::EmberEntity*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventFrameStarted of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__GUIManager_EventFrameStarted
static int tolua_get_EmberOgre__GUIManager_EventFrameStarted(lua_State* tolua_S)
{
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventFrameStarted'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventFrameStarted,"sigc::signal<void,float>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventFrameStarted of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__GUIManager_EventFrameStarted
static int tolua_set_EmberOgre__GUIManager_EventFrameStarted(lua_State* tolua_S)
{
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventFrameStarted'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,float>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventFrameStarted = *((sigc::signal<void,float>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeWidget of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_removeWidget00
static int tolua_EmberOgre_EmberOgre_GUIManager_removeWidget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::Widget* widget = ((EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeWidget'", NULL);
#endif
  {
   self->removeWidget(widget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeWidget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addWidget of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_addWidget00
static int tolua_EmberOgre_EmberOgre_GUIManager_addWidget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::Widget* widget = ((EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addWidget'", NULL);
#endif
  {
   self->addWidget(widget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addWidget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: EmitEntityAction of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_EmitEntityAction00
static int tolua_EmberOgre_EmberOgre_GUIManager_EmitEntityAction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string action = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'EmitEntityAction'", NULL);
#endif
  {
   self->EmitEntityAction(action,entity);
   tolua_pushcppstring(tolua_S,(const char*)action);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'EmitEntityAction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMainSheet of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_getMainSheet00
static int tolua_EmberOgre_EmberOgre_GUIManager_getMainSheet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMainSheet'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getMainSheet();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMainSheet'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isInGUIMode of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_isInGUIMode00
static int tolua_EmberOgre_EmberOgre_GUIManager_isInGUIMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::GUIManager* self = (const EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isInGUIMode'", NULL);
#endif
  {
   const bool tolua_ret = (const bool)  self->isInGUIMode();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isInGUIMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isInMovementKeysMode of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_isInMovementKeysMode00
static int tolua_EmberOgre_EmberOgre_GUIManager_isInMovementKeysMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::GUIManager* self = (const EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isInMovementKeysMode'", NULL);
#endif
  {
   const bool tolua_ret = (const bool)  self->isInMovementKeysMode();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isInMovementKeysMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createWindow of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_createWindow00
static int tolua_EmberOgre_EmberOgre_GUIManager_createWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string windowType = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createWindow'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->createWindow(windowType);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
   tolua_pushcppstring(tolua_S,(const char*)windowType);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createWindow of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_createWindow01
static int tolua_EmberOgre_EmberOgre_GUIManager_createWindow01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string windowType = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string windowName = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createWindow'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->createWindow(windowType,windowName);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
   tolua_pushcppstring(tolua_S,(const char*)windowType);
   tolua_pushcppstring(tolua_S,(const char*)windowName);
  }
 }
 return 3;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_GUIManager_createWindow00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: createWidget of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_createWidget00
static int tolua_EmberOgre_EmberOgre_GUIManager_createWidget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createWidget'", NULL);
#endif
  {
   EmberOgre::Gui::Widget* tolua_ret = (EmberOgre::Gui::Widget*)  self->createWidget();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Widget");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createWidget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createWidget of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_createWidget01
static int tolua_EmberOgre_EmberOgre_GUIManager_createWidget01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createWidget'", NULL);
#endif
  {
   EmberOgre::Gui::Widget* tolua_ret = (EmberOgre::Gui::Widget*)  self->createWidget(name);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Widget");
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 2;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_GUIManager_createWidget00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyWidget of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_destroyWidget00
static int tolua_EmberOgre_EmberOgre_GUIManager_destroyWidget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::Widget* widget = ((EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyWidget'", NULL);
#endif
  {
   self->destroyWidget(widget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyWidget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultScheme of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_getDefaultScheme00
static int tolua_EmberOgre_EmberOgre_GUIManager_getDefaultScheme00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::GUIManager* self = (const EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefaultScheme'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getDefaultScheme();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultScheme'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIconManager of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_getIconManager00
static int tolua_EmberOgre_EmberOgre_GUIManager_getIconManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIconManager'", NULL);
#endif
  {
   EmberOgre::Gui::Icons::IconManager* tolua_ret = (EmberOgre::Gui::Icons::IconManager*)  self->getIconManager();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Icons::IconManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIconManager'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEntityIconManager of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_getEntityIconManager00
static int tolua_EmberOgre_EmberOgre_GUIManager_getEntityIconManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEntityIconManager'", NULL);
#endif
  {
   EmberOgre::Gui::EntityIconManager* tolua_ret = (EmberOgre::Gui::EntityIconManager*)  self->getEntityIconManager();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityIconManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEntityIconManager'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getActionBarIconManager of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_getActionBarIconManager00
static int tolua_EmberOgre_EmberOgre_GUIManager_getActionBarIconManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::GUIManager* self = (EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getActionBarIconManager'", NULL);
#endif
  {
   EmberOgre::Gui::ActionBarIconManager* tolua_ret = (EmberOgre::Gui::ActionBarIconManager*)  self->getActionBarIconManager();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ActionBarIconManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getActionBarIconManager'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEntityTooltip of class  EmberOgre::GUIManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_GUIManager_getEntityTooltip00
static int tolua_EmberOgre_EmberOgre_GUIManager_getEntityTooltip00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::GUIManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::GUIManager* self = (const EmberOgre::GUIManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEntityTooltip'", NULL);
#endif
  {
   EmberOgre::Gui::EntityTooltip* tolua_ret = (EmberOgre::Gui::EntityTooltip*)  self->getEntityTooltip();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityTooltip");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEntityTooltip'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Terrain::TerrainArea */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_new00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Terrain::TerrainArea",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::EmberEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Terrain::TerrainArea* tolua_ret = (EmberOgre::Terrain::TerrainArea*)  Mtolua_new((EmberOgre::Terrain::TerrainArea)(*entity));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Terrain::TerrainArea");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Terrain::TerrainArea */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_new00_local
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Terrain::TerrainArea",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::EmberEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Terrain::TerrainArea* tolua_ret = (EmberOgre::Terrain::TerrainArea*)  Mtolua_new((EmberOgre::Terrain::TerrainArea)(*entity));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Terrain::TerrainArea");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: init of class  EmberOgre::Terrain::TerrainArea */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_init00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_init00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainArea* self = (EmberOgre::Terrain::TerrainArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'init'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->init();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'init'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getArea of class  EmberOgre::Terrain::TerrainArea */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_getArea00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_getArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainArea* self = (const EmberOgre::Terrain::TerrainArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getArea'", NULL);
#endif
  {
   Mercator::Area* tolua_ret = (Mercator::Area*)  self->getArea();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Mercator::Area");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setArea of class  EmberOgre::Terrain::TerrainArea */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_setArea00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_setArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainArea",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Mercator::Area",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainArea* self = (EmberOgre::Terrain::TerrainArea*)  tolua_tousertype(tolua_S,1,0);
  Mercator::Area* area = ((Mercator::Area*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setArea'", NULL);
#endif
  {
   self->setArea(area);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getName of class  EmberOgre::Terrain::TerrainLayerDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getName00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainLayerDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainLayerDefinition* self = (const EmberOgre::Terrain::TerrainLayerDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAreaId of class  EmberOgre::Terrain::TerrainLayerDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getAreaId00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getAreaId00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainLayerDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainLayerDefinition* self = (const EmberOgre::Terrain::TerrainLayerDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAreaId'", NULL);
#endif
  {
   unsigned int tolua_ret = (unsigned int)  self->getAreaId();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAreaId'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDiffuseTextureName of class  EmberOgre::Terrain::TerrainLayerDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getDiffuseTextureName00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getDiffuseTextureName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainLayerDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainLayerDefinition* self = (const EmberOgre::Terrain::TerrainLayerDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDiffuseTextureName'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getDiffuseTextureName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDiffuseTextureName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNormalMapTextureName of class  EmberOgre::Terrain::TerrainLayerDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getNormalMapTextureName00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getNormalMapTextureName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainLayerDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainLayerDefinition* self = (const EmberOgre::Terrain::TerrainLayerDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNormalMapTextureName'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getNormalMapTextureName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNormalMapTextureName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getShaderName of class  EmberOgre::Terrain::TerrainLayerDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getShaderName00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getShaderName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainLayerDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainLayerDefinition* self = (const EmberOgre::Terrain::TerrainLayerDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getShaderName'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getShaderName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getShaderName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTileSize of class  EmberOgre::Terrain::TerrainLayerDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getTileSize00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getTileSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainLayerDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainLayerDefinition* self = (const EmberOgre::Terrain::TerrainLayerDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTileSize'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getTileSize();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTileSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDebugInfo of class  EmberOgre::Terrain::ISceneManagerAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_ISceneManagerAdapter_getDebugInfo00
static int tolua_EmberOgre_EmberOgre_Terrain_ISceneManagerAdapter_getDebugInfo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::ISceneManagerAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::ISceneManagerAdapter* self = (EmberOgre::Terrain::ISceneManagerAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDebugInfo'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getDebugInfo();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDebugInfo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMax of class  EmberOgre::Terrain::TerrainManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getMax00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getMax00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainManager* self = (const EmberOgre::Terrain::TerrainManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMax'", NULL);
#endif
  {
   const WFMath::Point<2> tolua_ret = (const WFMath::Point<2>)  self->getMax();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((WFMath::Point<2>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"const WFMath::Point<2>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const WFMath::Point<2>));
     tolua_pushusertype(tolua_S,tolua_obj,"const WFMath::Point<2>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMax'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMin of class  EmberOgre::Terrain::TerrainManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getMin00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getMin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainManager* self = (const EmberOgre::Terrain::TerrainManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMin'", NULL);
#endif
  {
   const WFMath::Point<2> tolua_ret = (const WFMath::Point<2>)  self->getMin();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((WFMath::Point<2>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"const WFMath::Point<2>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const WFMath::Point<2>));
     tolua_pushusertype(tolua_S,tolua_obj,"const WFMath::Point<2>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPageMetersSize of class  EmberOgre::Terrain::TerrainManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getPageMetersSize00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getPageMetersSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainManager* self = (EmberOgre::Terrain::TerrainManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPageMetersSize'", NULL);
#endif
  {
   int tolua_ret = (int)  self->getPageMetersSize();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPageMetersSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: updateShadows of class  EmberOgre::Terrain::TerrainManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_updateShadows00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_updateShadows00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainManager* self = (EmberOgre::Terrain::TerrainManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'updateShadows'", NULL);
#endif
  {
   self->updateShadows();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'updateShadows'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: UpdateShadows of class  EmberOgre::Terrain::TerrainManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Terrain__TerrainManager_UpdateShadows
static int tolua_get_EmberOgre__Terrain__TerrainManager_UpdateShadows(lua_State* tolua_S)
{
  EmberOgre::Terrain::TerrainManager* self = (EmberOgre::Terrain::TerrainManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UpdateShadows'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->UpdateShadows,"const Ember::ConsoleCommandWrapper");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventTerrainPageGeometryUpdated of class  EmberOgre::Terrain::TerrainManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Terrain__TerrainManager_EventTerrainPageGeometryUpdated
static int tolua_get_EmberOgre__Terrain__TerrainManager_EventTerrainPageGeometryUpdated(lua_State* tolua_S)
{
  EmberOgre::Terrain::TerrainManager* self = (EmberOgre::Terrain::TerrainManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventTerrainPageGeometryUpdated'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventTerrainPageGeometryUpdated,"sigc::signal<void,EmberOgre::Terrain::TerrainPage&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventTerrainPageGeometryUpdated of class  EmberOgre::Terrain::TerrainManager */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Terrain__TerrainManager_EventTerrainPageGeometryUpdated
static int tolua_set_EmberOgre__Terrain__TerrainManager_EventTerrainPageGeometryUpdated(lua_State* tolua_S)
{
  EmberOgre::Terrain::TerrainManager* self = (EmberOgre::Terrain::TerrainManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventTerrainPageGeometryUpdated'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Terrain::TerrainPage&>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventTerrainPageGeometryUpdated = *((sigc::signal<void,EmberOgre::Terrain::TerrainPage&>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAdapter of class  EmberOgre::Terrain::TerrainManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getAdapter00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainManager* self = (const EmberOgre::Terrain::TerrainManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAdapter'", NULL);
#endif
  {
   EmberOgre::Terrain::ISceneManagerAdapter* tolua_ret = (EmberOgre::Terrain::ISceneManagerAdapter*)  self->getAdapter();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Terrain::ISceneManagerAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getScene of class  EmberOgre::Terrain::TerrainManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getScene00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getScene00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainManager* self = (const EmberOgre::Terrain::TerrainManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getScene'", NULL);
#endif
  {
   EmberOgre::Scene& tolua_ret = (EmberOgre::Scene&)  self->getScene();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Scene");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getScene'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBasePoint of class  EmberOgre::Terrain::BasePointUserObject */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_getBasePoint00
static int tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_getBasePoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::BasePointUserObject",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::BasePointUserObject* self = (const EmberOgre::Terrain::BasePointUserObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBasePoint'", NULL);
#endif
  {
   const Mercator::BasePoint& tolua_ret = (const Mercator::BasePoint&)  self->getBasePoint();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Mercator::BasePoint");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBasePoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBasePointMarkerNode of class  EmberOgre::Terrain::BasePointUserObject */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_getBasePointMarkerNode00
static int tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_getBasePointMarkerNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::BasePointUserObject",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::BasePointUserObject* self = (const EmberOgre::Terrain::BasePointUserObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBasePointMarkerNode'", NULL);
#endif
  {
   Ogre::SceneNode* tolua_ret = (Ogre::SceneNode*)  self->getBasePointMarkerNode();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ogre::SceneNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBasePointMarkerNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPosition of class  EmberOgre::Terrain::BasePointUserObject */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_getPosition00
static int tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_getPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::BasePointUserObject",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::BasePointUserObject* self = (const EmberOgre::Terrain::BasePointUserObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPosition'", NULL);
#endif
  {
   const EmberOgre::TerrainPosition& tolua_ret = (const EmberOgre::TerrainPosition&)  self->getPosition();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const EmberOgre::TerrainPosition");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHeight of class  EmberOgre::Terrain::BasePointUserObject */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_getHeight00
static int tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_getHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::BasePointUserObject",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::BasePointUserObject* self = (const EmberOgre::Terrain::BasePointUserObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHeight'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: translate of class  EmberOgre::Terrain::BasePointUserObject */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_translate00
static int tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_translate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::BasePointUserObject",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::BasePointUserObject* self = (EmberOgre::Terrain::BasePointUserObject*)  tolua_tousertype(tolua_S,1,0);
  float verticalMovement = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'translate'", NULL);
#endif
  {
   self->translate(verticalMovement);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'translate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventUpdatedPosition of class  EmberOgre::Terrain::BasePointUserObject */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Terrain__BasePointUserObject_EventUpdatedPosition
static int tolua_get_EmberOgre__Terrain__BasePointUserObject_EventUpdatedPosition(lua_State* tolua_S)
{
  EmberOgre::Terrain::BasePointUserObject* self = (EmberOgre::Terrain::BasePointUserObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventUpdatedPosition'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventUpdatedPosition,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventUpdatedPosition of class  EmberOgre::Terrain::BasePointUserObject */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Terrain__BasePointUserObject_EventUpdatedPosition
static int tolua_set_EmberOgre__Terrain__BasePointUserObject_EventUpdatedPosition(lua_State* tolua_S)
{
  EmberOgre::Terrain::BasePointUserObject* self = (EmberOgre::Terrain::BasePointUserObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventUpdatedPosition'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventUpdatedPosition = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMovements of class  EmberOgre::Terrain::TerrainEditAction */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditAction_getMovements00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditAction_getMovements00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainEditAction",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainEditAction* self = (const EmberOgre::Terrain::TerrainEditAction*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMovements'", NULL);
#endif
  {
    const std::vector<EmberOgre::Terrain::TerrainEditBasePointMovement>& tolua_ret = (  const std::vector<EmberOgre::Terrain::TerrainEditBasePointMovement>&)  self->getMovements();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const std::vector<EmberOgre::Terrain::TerrainEditBasePointMovement>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMovements'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMovements of class  EmberOgre::Terrain::TerrainEditAction */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditAction_getMovements01
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditAction_getMovements01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainEditAction",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::Terrain::TerrainEditAction* self = (EmberOgre::Terrain::TerrainEditAction*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMovements'", NULL);
#endif
  {
    std::vector<EmberOgre::Terrain::TerrainEditBasePointMovement>& tolua_ret = (  std::vector<EmberOgre::Terrain::TerrainEditBasePointMovement>&)  self->getMovements();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"std::vector<EmberOgre::Terrain::TerrainEditBasePointMovement>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Terrain_TerrainEditAction_getMovements00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVerticalMovement of class  EmberOgre::Terrain::TerrainEditBasePointMovement */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditBasePointMovement_getVerticalMovement00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditBasePointMovement_getVerticalMovement00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainEditBasePointMovement",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainEditBasePointMovement* self = (const EmberOgre::Terrain::TerrainEditBasePointMovement*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVerticalMovement'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getVerticalMovement();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVerticalMovement'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPosition of class  EmberOgre::Terrain::TerrainEditBasePointMovement */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditBasePointMovement_getPosition00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditBasePointMovement_getPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainEditBasePointMovement",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainEditBasePointMovement* self = (const EmberOgre::Terrain::TerrainEditBasePointMovement*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPosition'", NULL);
#endif
  {
   const EmberOgre::TerrainPosition& tolua_ret = (const EmberOgre::TerrainPosition&)  self->getPosition();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const EmberOgre::TerrainPosition");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_new00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Terrain::TerrainEditor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Terrain::TerrainManager",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"EmberOgre::Camera::MainCamera",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainManager* manager = ((EmberOgre::Terrain::TerrainManager*)  tolua_tousertype(tolua_S,2,0));
  EmberOgre::Camera::MainCamera* camera = ((EmberOgre::Camera::MainCamera*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Terrain::TerrainEditor* tolua_ret = (EmberOgre::Terrain::TerrainEditor*)  Mtolua_new((EmberOgre::Terrain::TerrainEditor)(*manager,*camera));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Terrain::TerrainEditor");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_new00_local
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Terrain::TerrainEditor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Terrain::TerrainManager",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"EmberOgre::Camera::MainCamera",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainManager* manager = ((EmberOgre::Terrain::TerrainManager*)  tolua_tousertype(tolua_S,2,0));
  EmberOgre::Camera::MainCamera* camera = ((EmberOgre::Camera::MainCamera*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Terrain::TerrainEditor* tolua_ret = (EmberOgre::Terrain::TerrainEditor*)  Mtolua_new((EmberOgre::Terrain::TerrainEditor)(*manager,*camera));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Terrain::TerrainEditor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_delete00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainEditor* self = (EmberOgre::Terrain::TerrainEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: showOverlay of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_showOverlay00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_showOverlay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainEditor* self = (EmberOgre::Terrain::TerrainEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'showOverlay'", NULL);
#endif
  {
   self->showOverlay();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'showOverlay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hideOverlay of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_hideOverlay00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_hideOverlay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainEditor* self = (EmberOgre::Terrain::TerrainEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hideOverlay'", NULL);
#endif
  {
   self->hideOverlay();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hideOverlay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isOverlayShown of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_isOverlayShown00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_isOverlayShown00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainEditor* self = (const EmberOgre::Terrain::TerrainEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isOverlayShown'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isOverlayShown();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isOverlayShown'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventOverlayCreated of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Terrain__TerrainEditor_EventOverlayCreated
static int tolua_get_EmberOgre__Terrain__TerrainEditor_EventOverlayCreated(lua_State* tolua_S)
{
  EmberOgre::Terrain::TerrainEditor* self = (EmberOgre::Terrain::TerrainEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventOverlayCreated'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventOverlayCreated,"sigc::signal<void,EmberOgre::Terrain::TerrainEditorOverlay&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventOverlayCreated of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Terrain__TerrainEditor_EventOverlayCreated
static int tolua_set_EmberOgre__Terrain__TerrainEditor_EventOverlayCreated(lua_State* tolua_S)
{
  EmberOgre::Terrain::TerrainEditor* self = (EmberOgre::Terrain::TerrainEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventOverlayCreated'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Terrain::TerrainEditorOverlay&>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventOverlayCreated = *((sigc::signal<void,EmberOgre::Terrain::TerrainEditorOverlay&>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventOverlayDestroyed of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Terrain__TerrainEditor_EventOverlayDestroyed
static int tolua_get_EmberOgre__Terrain__TerrainEditor_EventOverlayDestroyed(lua_State* tolua_S)
{
  EmberOgre::Terrain::TerrainEditor* self = (EmberOgre::Terrain::TerrainEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventOverlayDestroyed'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventOverlayDestroyed,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventOverlayDestroyed of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Terrain__TerrainEditor_EventOverlayDestroyed
static int tolua_set_EmberOgre__Terrain__TerrainEditor_EventOverlayDestroyed(lua_State* tolua_S)
{
  EmberOgre::Terrain::TerrainEditor* self = (EmberOgre::Terrain::TerrainEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventOverlayDestroyed'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventOverlayDestroyed = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRadius of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_getRadius00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_getRadius00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainEditor* self = (const EmberOgre::Terrain::TerrainEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRadius'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getRadius();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRadius'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRadius of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_setRadius00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_setRadius00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainEditor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainEditor* self = (EmberOgre::Terrain::TerrainEditor*)  tolua_tousertype(tolua_S,1,0);
  float radiusInMeters = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRadius'", NULL);
#endif
  {
   self->setRadius(radiusInMeters);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRadius'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFalloff of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_getFalloff00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_getFalloff00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainEditor* self = (const EmberOgre::Terrain::TerrainEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFalloff'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getFalloff();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFalloff'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFalloff of class  EmberOgre::Terrain::TerrainEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_setFalloff00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_setFalloff00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainEditor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainEditor* self = (EmberOgre::Terrain::TerrainEditor*)  tolua_tousertype(tolua_S,1,0);
  float falloff = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFalloff'", NULL);
#endif
  {
   self->setFalloff(falloff);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFalloff'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: commitAction of class  EmberOgre::Terrain::TerrainEditorOverlay */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_commitAction00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_commitAction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainEditorOverlay",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const EmberOgre::Terrain::TerrainEditAction",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainEditorOverlay* self = (EmberOgre::Terrain::TerrainEditorOverlay*)  tolua_tousertype(tolua_S,1,0);
  const EmberOgre::Terrain::TerrainEditAction* action = ((const EmberOgre::Terrain::TerrainEditAction*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'commitAction'", NULL);
#endif
  {
   self->commitAction(*action);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'commitAction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentBasePointUserObject of class  EmberOgre::Terrain::TerrainEditorOverlay */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_getCurrentBasePointUserObject00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_getCurrentBasePointUserObject00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainEditorOverlay",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainEditorOverlay* self = (const EmberOgre::Terrain::TerrainEditorOverlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentBasePointUserObject'", NULL);
#endif
  {
   EmberOgre::Terrain::BasePointUserObject* tolua_ret = (EmberOgre::Terrain::BasePointUserObject*)  self->getCurrentBasePointUserObject();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Terrain::BasePointUserObject");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCurrentBasePointUserObject'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sendChangesToServer of class  EmberOgre::Terrain::TerrainEditorOverlay */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_sendChangesToServer00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_sendChangesToServer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainEditorOverlay",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainEditorOverlay* self = (EmberOgre::Terrain::TerrainEditorOverlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sendChangesToServer'", NULL);
#endif
  {
   self->sendChangesToServer();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sendChangesToServer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createAction of class  EmberOgre::Terrain::TerrainEditorOverlay */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_createAction00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_createAction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainEditorOverlay",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainEditorOverlay* self = (EmberOgre::Terrain::TerrainEditorOverlay*)  tolua_tousertype(tolua_S,1,0);
  bool alsoCommit = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createAction'", NULL);
#endif
  {
   self->createAction(alsoCommit);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createAction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: undoLastAction of class  EmberOgre::Terrain::TerrainEditorOverlay */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_undoLastAction00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_undoLastAction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainEditorOverlay",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainEditorOverlay* self = (EmberOgre::Terrain::TerrainEditorOverlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'undoLastAction'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->undoLastAction();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'undoLastAction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: redoAction of class  EmberOgre::Terrain::TerrainEditorOverlay */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_redoAction00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_redoAction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainEditorOverlay",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainEditorOverlay* self = (EmberOgre::Terrain::TerrainEditorOverlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'redoAction'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->redoAction();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'redoAction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventPickedBasePoint of class  EmberOgre::Terrain::TerrainEditorOverlay */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Terrain__TerrainEditorOverlay_EventPickedBasePoint
static int tolua_get_EmberOgre__Terrain__TerrainEditorOverlay_EventPickedBasePoint(lua_State* tolua_S)
{
  EmberOgre::Terrain::TerrainEditorOverlay* self = (EmberOgre::Terrain::TerrainEditorOverlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventPickedBasePoint'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventPickedBasePoint,"sigc::signal<void,EmberOgre::Terrain::BasePointUserObject*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventPickedBasePoint of class  EmberOgre::Terrain::TerrainEditorOverlay */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Terrain__TerrainEditorOverlay_EventPickedBasePoint
static int tolua_set_EmberOgre__Terrain__TerrainEditorOverlay_EventPickedBasePoint(lua_State* tolua_S)
{
  EmberOgre::Terrain::TerrainEditorOverlay* self = (EmberOgre::Terrain::TerrainEditorOverlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventPickedBasePoint'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Terrain::BasePointUserObject*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventPickedBasePoint = *((sigc::signal<void,EmberOgre::Terrain::BasePointUserObject*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventActionCreated of class  EmberOgre::Terrain::TerrainEditorOverlay */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Terrain__TerrainEditorOverlay_EventActionCreated
static int tolua_get_EmberOgre__Terrain__TerrainEditorOverlay_EventActionCreated(lua_State* tolua_S)
{
  EmberOgre::Terrain::TerrainEditorOverlay* self = (EmberOgre::Terrain::TerrainEditorOverlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventActionCreated'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventActionCreated,"sigc::signal<void,const EmberOgre::Terrain::TerrainEditAction*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventSelectedBasePointUpdatedPosition of class  EmberOgre::Terrain::TerrainEditorOverlay */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Terrain__TerrainEditorOverlay_EventSelectedBasePointUpdatedPosition
static int tolua_get_EmberOgre__Terrain__TerrainEditorOverlay_EventSelectedBasePointUpdatedPosition(lua_State* tolua_S)
{
  EmberOgre::Terrain::TerrainEditorOverlay* self = (EmberOgre::Terrain::TerrainEditorOverlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventSelectedBasePointUpdatedPosition'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventSelectedBasePointUpdatedPosition,"sigc::signal<void,EmberOgre::Terrain::BasePointUserObject*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventSelectedBasePointUpdatedPosition of class  EmberOgre::Terrain::TerrainEditorOverlay */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Terrain__TerrainEditorOverlay_EventSelectedBasePointUpdatedPosition
static int tolua_set_EmberOgre__Terrain__TerrainEditorOverlay_EventSelectedBasePointUpdatedPosition(lua_State* tolua_S)
{
  EmberOgre::Terrain::TerrainEditorOverlay* self = (EmberOgre::Terrain::TerrainEditorOverlay*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventSelectedBasePointUpdatedPosition'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Terrain::BasePointUserObject*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventSelectedBasePointUpdatedPosition = *((sigc::signal<void,EmberOgre::Terrain::BasePointUserObject*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: updateAnimation of class  EmberOgre::IAnimated */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_IAnimated_updateAnimation00
static int tolua_EmberOgre_EmberOgre_IAnimated_updateAnimation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::IAnimated",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::IAnimated* self = (EmberOgre::IAnimated*)  tolua_tousertype(tolua_S,1,0);
  float timeSlice = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'updateAnimation'", NULL);
#endif
  {
   self->updateAnimation(timeSlice);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'updateAnimation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AnimatedEntities of class  MotionManagerInfo */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__MotionManager__MotionManagerInfo_AnimatedEntities
static int tolua_get_EmberOgre__MotionManager__MotionManagerInfo_AnimatedEntities(lua_State* tolua_S)
{
  EmberOgre::MotionManager::MotionManagerInfo* self = (EmberOgre::MotionManager::MotionManagerInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AnimatedEntities'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AnimatedEntities);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AnimatedEntities of class  MotionManagerInfo */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__MotionManager__MotionManagerInfo_AnimatedEntities
static int tolua_set_EmberOgre__MotionManager__MotionManagerInfo_AnimatedEntities(lua_State* tolua_S)
{
  EmberOgre::MotionManager::MotionManagerInfo* self = (EmberOgre::MotionManager::MotionManagerInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AnimatedEntities'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AnimatedEntities = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: MovingEntities of class  MotionManagerInfo */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__MotionManager__MotionManagerInfo_MovingEntities
static int tolua_get_EmberOgre__MotionManager__MotionManagerInfo_MovingEntities(lua_State* tolua_S)
{
  EmberOgre::MotionManager::MotionManagerInfo* self = (EmberOgre::MotionManager::MotionManagerInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MovingEntities'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->MovingEntities);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: MovingEntities of class  MotionManagerInfo */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__MotionManager__MotionManagerInfo_MovingEntities
static int tolua_set_EmberOgre__MotionManager__MotionManagerInfo_MovingEntities(lua_State* tolua_S)
{
  EmberOgre::MotionManager::MotionManagerInfo* self = (EmberOgre::MotionManager::MotionManagerInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MovingEntities'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->MovingEntities = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  EmberOgre::MotionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_MotionManager_getSingleton00
static int tolua_EmberOgre_EmberOgre_MotionManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::MotionManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::MotionManager& tolua_ret = (EmberOgre::MotionManager&)  EmberOgre::MotionManager::getSingleton();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::MotionManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInfo of class  EmberOgre::MotionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_MotionManager_getInfo00
static int tolua_EmberOgre_EmberOgre_MotionManager_getInfo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::MotionManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::MotionManager* self = (const EmberOgre::MotionManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInfo'", NULL);
#endif
  {
   const EmberOgre::MotionManager::MotionManagerInfo& tolua_ret = (const EmberOgre::MotionManager::MotionManagerInfo&)  self->getInfo();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const EmberOgre::MotionManager::MotionManagerInfo");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInfo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: show of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_show00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_show00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'show'", NULL);
#endif
  {
   self->show();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'show'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hide of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_hide00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_hide00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hide'", NULL);
#endif
  {
   self->hide();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hide'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isVisible of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_isVisible00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_isVisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isVisible'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isVisible();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isActive of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_isActive00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_isActive00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isActive'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isActive();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isActive'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWindow of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_getWindow00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_getWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
  const std::string windowName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWindow'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getWindow(windowName);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
   tolua_pushcppstring(tolua_S,(const char*)windowName);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: enableCloseButton of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_enableCloseButton00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_enableCloseButton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'enableCloseButton'", NULL);
#endif
  {
   self->enableCloseButton();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'enableCloseButton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: registerConsoleVisibilityToggleCommand of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_registerConsoleVisibilityToggleCommand00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_registerConsoleVisibilityToggleCommand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
  const std::string commandSuffix = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'registerConsoleVisibilityToggleCommand'", NULL);
#endif
  {
   self->registerConsoleVisibilityToggleCommand(commandSuffix);
   tolua_pushcppstring(tolua_S,(const char*)commandSuffix);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'registerConsoleVisibilityToggleCommand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMainSheet of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_getMainSheet00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_getMainSheet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMainSheet'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getMainSheet();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMainSheet'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMainWindow of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_getMainWindow00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_getMainWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMainWindow'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getMainWindow();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMainWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createWindow of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_createWindow00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_createWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
  const std::string windowType = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createWindow'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->createWindow(windowType);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
   tolua_pushcppstring(tolua_S,(const char*)windowType);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createWindow of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_createWindow01
static int tolua_EmberOgre_EmberOgre_Gui_Widget_createWindow01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
  const std::string windowType = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string windowName = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createWindow'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->createWindow(windowType,windowName);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
   tolua_pushcppstring(tolua_S,(const char*)windowType);
   tolua_pushcppstring(tolua_S,(const char*)windowName);
  }
 }
 return 3;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_Widget_createWindow00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: loadMainSheet of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_loadMainSheet00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_loadMainSheet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
  const std::string filename = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string prefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadMainSheet'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->loadMainSheet(filename,prefix);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
   tolua_pushcppstring(tolua_S,(const char*)filename);
   tolua_pushcppstring(tolua_S,(const char*)prefix);
  }
 }
 return 3;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadMainSheet'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPrefix of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_getPrefix00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_getPrefix00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Widget* self = (const EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPrefix'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getPrefix();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPrefix'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIsActiveWindowOpaque of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_getIsActiveWindowOpaque00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_getIsActiveWindowOpaque00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Widget* self = (const EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIsActiveWindowOpaque'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getIsActiveWindowOpaque();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIsActiveWindowOpaque'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setIsActiveWindowOpaque of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_setIsActiveWindowOpaque00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_setIsActiveWindowOpaque00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
  bool isOpaque = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setIsActiveWindowOpaque'", NULL);
#endif
  {
   self->setIsActiveWindowOpaque(isOpaque);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setIsActiveWindowOpaque'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultScheme of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_getDefaultScheme00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_getDefaultScheme00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Widget* self = (const EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefaultScheme'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getDefaultScheme();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultScheme'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addTabbableWindow of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_addTabbableWindow00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_addTabbableWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addTabbableWindow'", NULL);
#endif
  {
   self->addTabbableWindow(window);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addTabbableWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: closeTabGroup of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Widget_closeTabGroup00
static int tolua_EmberOgre_EmberOgre_Gui_Widget_closeTabGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Widget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'closeTabGroup'", NULL);
#endif
  {
   self->closeTabGroup();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'closeTabGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventFrameStarted of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__Widget_EventFrameStarted
static int tolua_get_EmberOgre__Gui__Widget_EventFrameStarted(lua_State* tolua_S)
{
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventFrameStarted'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventFrameStarted,"sigc::signal<void,float>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventFrameStarted of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__Widget_EventFrameStarted
static int tolua_set_EmberOgre__Gui__Widget_EventFrameStarted(lua_State* tolua_S)
{
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventFrameStarted'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,float>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventFrameStarted = *((sigc::signal<void,float>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventFirstTimeShown of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__Widget_EventFirstTimeShown
static int tolua_get_EmberOgre__Gui__Widget_EventFirstTimeShown(lua_State* tolua_S)
{
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventFirstTimeShown'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventFirstTimeShown,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventFirstTimeShown of class  EmberOgre::Gui::Widget */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__Widget_EventFirstTimeShown
static int tolua_set_EmberOgre__Gui__Widget_EventFirstTimeShown(lua_State* tolua_S)
{
  EmberOgre::Gui::Widget* self = (EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventFirstTimeShown'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventFirstTimeShown = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::IconBase */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBase_new00
static int tolua_EmberOgre_EmberOgre_Gui_IconBase_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::IconBase",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const CEGUI::Image* background = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Image* foreground = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Image* borderInactive = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,5,0));
  const CEGUI::Image* borderActive = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,6,0));
  {
   EmberOgre::Gui::IconBase* tolua_ret = (EmberOgre::Gui::IconBase*)  Mtolua_new((EmberOgre::Gui::IconBase)(name,background,foreground,borderInactive,borderActive));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::IconBase");
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::IconBase */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBase_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_IconBase_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::IconBase",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const CEGUI::Image* background = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Image* foreground = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Image* borderInactive = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,5,0));
  const CEGUI::Image* borderActive = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,6,0));
  {
   EmberOgre::Gui::IconBase* tolua_ret = (EmberOgre::Gui::IconBase*)  Mtolua_new((EmberOgre::Gui::IconBase)(name,background,foreground,borderInactive,borderActive));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::IconBase");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::IconBase */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBase_new01
static int tolua_EmberOgre_EmberOgre_Gui_IconBase_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::IconBase",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"const CEGUI::Image",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"CEGUI::UVector2",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const CEGUI::Image* background = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Image* foreground = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Image* borderInactive = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,5,0));
  const CEGUI::Image* borderActive = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,6,0));
  CEGUI::UVector2 size = *((CEGUI::UVector2*)  tolua_tousertype(tolua_S,7,0));
  {
   EmberOgre::Gui::IconBase* tolua_ret = (EmberOgre::Gui::IconBase*)  Mtolua_new((EmberOgre::Gui::IconBase)(name,background,foreground,borderInactive,borderActive,size));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::IconBase");
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 2;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_IconBase_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::IconBase */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBase_new01_local
static int tolua_EmberOgre_EmberOgre_Gui_IconBase_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::IconBase",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"const CEGUI::Image",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"CEGUI::UVector2",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const CEGUI::Image* background = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Image* foreground = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Image* borderInactive = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,5,0));
  const CEGUI::Image* borderActive = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,6,0));
  CEGUI::UVector2 size = *((CEGUI::UVector2*)  tolua_tousertype(tolua_S,7,0));
  {
   EmberOgre::Gui::IconBase* tolua_ret = (EmberOgre::Gui::IconBase*)  Mtolua_new((EmberOgre::Gui::IconBase)(name,background,foreground,borderInactive,borderActive,size));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::IconBase");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 2;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_IconBase_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::IconBase */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBase_delete00
static int tolua_EmberOgre_EmberOgre_Gui_IconBase_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::IconBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::IconBase* self = (EmberOgre::Gui::IconBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getContainer of class  EmberOgre::Gui::IconBase */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBase_getContainer00
static int tolua_EmberOgre_EmberOgre_Gui_IconBase_getContainer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::IconBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::IconBase* self = (EmberOgre::Gui::IconBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getContainer'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getContainer();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getContainer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getButton of class  EmberOgre::Gui::IconBase */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBase_getButton00
static int tolua_EmberOgre_EmberOgre_Gui_IconBase_getButton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::IconBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::IconBase* self = (EmberOgre::Gui::IconBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getButton'", NULL);
#endif
  {
   CEGUI::PushButton* tolua_ret = (CEGUI::PushButton*)  self->getButton();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::PushButton");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getButton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setForeground of class  EmberOgre::Gui::IconBase */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBase_setForeground00
static int tolua_EmberOgre_EmberOgre_Gui_IconBase_setForeground00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::IconBase",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::IconBase* self = (EmberOgre::Gui::IconBase*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Image* image = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setForeground'", NULL);
#endif
  {
   self->setForeground(image);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setForeground'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: loadImageFromImageset of class  EmberOgre::Gui::IconBase */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBase_loadImageFromImageset00
static int tolua_EmberOgre_EmberOgre_Gui_IconBase_loadImageFromImageset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::IconBase",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string imagesetName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string image = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  {
   const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  EmberOgre::Gui::IconBase::loadImageFromImageset(imagesetName,image);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
   tolua_pushcppstring(tolua_S,(const char*)imagesetName);
   tolua_pushcppstring(tolua_S,(const char*)image);
  }
 }
 return 3;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadImageFromImageset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::IconBar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBar_new00
static int tolua_EmberOgre_EmberOgre_Gui_IconBar_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::IconBar",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   EmberOgre::Gui::IconBar* tolua_ret = (EmberOgre::Gui::IconBar*)  Mtolua_new((EmberOgre::Gui::IconBar)(name));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::IconBar");
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::IconBar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBar_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_IconBar_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::IconBar",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   EmberOgre::Gui::IconBar* tolua_ret = (EmberOgre::Gui::IconBar*)  Mtolua_new((EmberOgre::Gui::IconBar)(name));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::IconBar");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::IconBar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBar_delete00
static int tolua_EmberOgre_EmberOgre_Gui_IconBar_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::IconBar",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::IconBar* self = (EmberOgre::Gui::IconBar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addIcon of class  EmberOgre::Gui::IconBar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBar_addIcon00
static int tolua_EmberOgre_EmberOgre_Gui_IconBar_addIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::IconBar",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::IconBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::IconBar* self = (EmberOgre::Gui::IconBar*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::IconBase* iconBase = ((EmberOgre::Gui::IconBase*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addIcon'", NULL);
#endif
  {
   self->addIcon(iconBase);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeIcon of class  EmberOgre::Gui::IconBar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBar_removeIcon00
static int tolua_EmberOgre_EmberOgre_Gui_IconBar_removeIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::IconBar",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::IconBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::IconBar* self = (EmberOgre::Gui::IconBar*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::IconBase* iconBase = ((EmberOgre::Gui::IconBase*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeIcon'", NULL);
#endif
  {
   self->removeIcon(iconBase);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWindow of class  EmberOgre::Gui::IconBar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBar_getWindow00
static int tolua_EmberOgre_EmberOgre_Gui_IconBar_getWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::IconBar",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::IconBar* self = (EmberOgre::Gui::IconBar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWindow'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getWindow();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setIconPadding of class  EmberOgre::Gui::IconBar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBar_setIconPadding00
static int tolua_EmberOgre_EmberOgre_Gui_IconBar_setIconPadding00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::IconBar",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::IconBar* self = (EmberOgre::Gui::IconBar*)  tolua_tousertype(tolua_S,1,0);
  int iconPadding = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setIconPadding'", NULL);
#endif
  {
   self->setIconPadding(iconPadding);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setIconPadding'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAbsoluteHeight of class  EmberOgre::Gui::IconBar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBar_getAbsoluteHeight00
static int tolua_EmberOgre_EmberOgre_Gui_IconBar_getAbsoluteHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::IconBar",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::IconBar* self = (EmberOgre::Gui::IconBar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAbsoluteHeight'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getAbsoluteHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAbsoluteHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAbsoluteWidth of class  EmberOgre::Gui::IconBar */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_IconBar_getAbsoluteWidth00
static int tolua_EmberOgre_EmberOgre_Gui_IconBar_getAbsoluteWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::IconBar",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::IconBar* self = (EmberOgre::Gui::IconBar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAbsoluteWidth'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getAbsoluteWidth();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAbsoluteWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::EntityEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityEditor_new00
static int tolua_EmberOgre_EmberOgre_Gui_EntityEditor_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::EntityEditor",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"EmberOgre::Gui::Adapters::Atlas::MapAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  EmberOgre::Gui::Adapters::Atlas::MapAdapter* rootAdapter = ((EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::EntityEditor* tolua_ret = (EmberOgre::Gui::EntityEditor*)  Mtolua_new((EmberOgre::Gui::EntityEditor)(entity,rootAdapter));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityEditor");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::EntityEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityEditor_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_EntityEditor_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::EntityEditor",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"EmberOgre::Gui::Adapters::Atlas::MapAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  EmberOgre::Gui::Adapters::Atlas::MapAdapter* rootAdapter = ((EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::EntityEditor* tolua_ret = (EmberOgre::Gui::EntityEditor*)  Mtolua_new((EmberOgre::Gui::EntityEditor)(entity,rootAdapter));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityEditor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::EntityEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityEditor_delete00
static int tolua_EmberOgre_EmberOgre_Gui_EntityEditor_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityEditor* self = (EmberOgre::Gui::EntityEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: submitChanges of class  EmberOgre::Gui::EntityEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityEditor_submitChanges00
static int tolua_EmberOgre_EmberOgre_Gui_EntityEditor_submitChanges00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityEditor* self = (EmberOgre::Gui::EntityEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'submitChanges'", NULL);
#endif
  {
   self->submitChanges();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'submitChanges'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createMapElement of class  EmberOgre::Gui::EntityEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createMapElement00
static int tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createMapElement00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityEditor* self = (EmberOgre::Gui::EntityEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createMapElement'", NULL);
#endif
  {
   Atlas::Message::Element tolua_ret = (Atlas::Message::Element)  self->createMapElement();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Atlas::Message::Element)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Message::Element));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createMapElement'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createListElement of class  EmberOgre::Gui::EntityEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createListElement00
static int tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createListElement00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityEditor* self = (EmberOgre::Gui::EntityEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createListElement'", NULL);
#endif
  {
   Atlas::Message::Element tolua_ret = (Atlas::Message::Element)  self->createListElement();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Atlas::Message::Element)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Message::Element));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createListElement'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createStringElement of class  EmberOgre::Gui::EntityEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createStringElement00
static int tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createStringElement00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityEditor* self = (EmberOgre::Gui::EntityEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createStringElement'", NULL);
#endif
  {
   Atlas::Message::Element tolua_ret = (Atlas::Message::Element)  self->createStringElement();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Atlas::Message::Element)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Message::Element));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createStringElement'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createIntElement of class  EmberOgre::Gui::EntityEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createIntElement00
static int tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createIntElement00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityEditor* self = (EmberOgre::Gui::EntityEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createIntElement'", NULL);
#endif
  {
   Atlas::Message::Element tolua_ret = (Atlas::Message::Element)  self->createIntElement();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Atlas::Message::Element)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Message::Element));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createIntElement'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createFloatElement of class  EmberOgre::Gui::EntityEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createFloatElement00
static int tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createFloatElement00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityEditor* self = (EmberOgre::Gui::EntityEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createFloatElement'", NULL);
#endif
  {
   Atlas::Message::Element tolua_ret = (Atlas::Message::Element)  self->createFloatElement();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Atlas::Message::Element)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Message::Element));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createFloatElement'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createPosition2dElement of class  EmberOgre::Gui::EntityEditor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createPosition2dElement00
static int tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createPosition2dElement00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityEditor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityEditor* self = (EmberOgre::Gui::EntityEditor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createPosition2dElement'", NULL);
#endif
  {
   Atlas::Message::Element tolua_ret = (Atlas::Message::Element)  self->createPosition2dElement();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Atlas::Message::Element)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Message::Element));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createPosition2dElement'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_new00
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::StackableContainer* tolua_ret = (EmberOgre::Gui::StackableContainer*)  Mtolua_new((EmberOgre::Gui::StackableContainer)(window));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::StackableContainer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::StackableContainer* tolua_ret = (EmberOgre::Gui::StackableContainer*)  Mtolua_new((EmberOgre::Gui::StackableContainer)(window));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::StackableContainer");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_delete00
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::StackableContainer* self = (EmberOgre::Gui::StackableContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setInnerContainerWindow of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_setInnerContainerWindow00
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_setInnerContainerWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::StackableContainer* self = (EmberOgre::Gui::StackableContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInnerContainerWindow'", NULL);
#endif
  {
   self->setInnerContainerWindow(window);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setInnerContainerWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWindow of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getWindow00
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::StackableContainer* self = (EmberOgre::Gui::StackableContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWindow'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getWindow();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPadding of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_setPadding00
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_setPadding00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::StackableContainer* self = (EmberOgre::Gui::StackableContainer*)  tolua_tousertype(tolua_S,1,0);
  int padding = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPadding'", NULL);
#endif
  {
   self->setPadding(padding);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPadding'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPadding of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getPadding00
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getPadding00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::StackableContainer* self = (const EmberOgre::Gui::StackableContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPadding'", NULL);
#endif
  {
   int tolua_ret = (int)  self->getPadding();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPadding'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAbsoluteHeight of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getAbsoluteHeight00
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getAbsoluteHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::StackableContainer* self = (EmberOgre::Gui::StackableContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAbsoluteHeight'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getAbsoluteHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAbsoluteHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAbsoluteWidth of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getAbsoluteWidth00
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getAbsoluteWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::StackableContainer* self = (EmberOgre::Gui::StackableContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAbsoluteWidth'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getAbsoluteWidth();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAbsoluteWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFlowDirection of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_setFlowDirection00
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_setFlowDirection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::StackableContainer* self = (EmberOgre::Gui::StackableContainer*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::StackableContainer::FlowDirection flowDirection = ((EmberOgre::Gui::StackableContainer::FlowDirection) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFlowDirection'", NULL);
#endif
  {
   self->setFlowDirection(flowDirection);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFlowDirection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFlowDirection of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getFlowDirection00
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getFlowDirection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::StackableContainer* self = (const EmberOgre::Gui::StackableContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFlowDirection'", NULL);
#endif
  {
   EmberOgre::Gui::StackableContainer::FlowDirection tolua_ret = (EmberOgre::Gui::StackableContainer::FlowDirection)  self->getFlowDirection();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFlowDirection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: repositionWindows of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_repositionWindows00
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_repositionWindows00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::StackableContainer* self = (EmberOgre::Gui::StackableContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'repositionWindows'", NULL);
#endif
  {
   self->repositionWindows();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'repositionWindows'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: disconnect of class  EmberOgre::Gui::StackableContainer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_StackableContainer_disconnect00
static int tolua_EmberOgre_EmberOgre_Gui_StackableContainer_disconnect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::StackableContainer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::StackableContainer* self = (EmberOgre::Gui::StackableContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'disconnect'", NULL);
#endif
  {
   self->disconnect();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'disconnect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::ConsoleAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ConsoleAdapter_new00
static int tolua_EmberOgre_EmberOgre_Gui_ConsoleAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ConsoleAdapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Editbox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Editbox* inputBox = ((CEGUI::Editbox*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::ConsoleAdapter* tolua_ret = (EmberOgre::Gui::ConsoleAdapter*)  Mtolua_new((EmberOgre::Gui::ConsoleAdapter)(inputBox));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ConsoleAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::ConsoleAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ConsoleAdapter_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_ConsoleAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ConsoleAdapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Editbox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Editbox* inputBox = ((CEGUI::Editbox*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::ConsoleAdapter* tolua_ret = (EmberOgre::Gui::ConsoleAdapter*)  Mtolua_new((EmberOgre::Gui::ConsoleAdapter)(inputBox));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ConsoleAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::ConsoleAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ConsoleAdapter_delete00
static int tolua_EmberOgre_EmberOgre_Gui_ConsoleAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ConsoleAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ConsoleAdapter* self = (EmberOgre::Gui::ConsoleAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventCommandExecuted of class  EmberOgre::Gui::ConsoleAdapter */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__ConsoleAdapter_EventCommandExecuted
static int tolua_get_EmberOgre__Gui__ConsoleAdapter_EventCommandExecuted(lua_State* tolua_S)
{
  EmberOgre::Gui::ConsoleAdapter* self = (EmberOgre::Gui::ConsoleAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventCommandExecuted'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventCommandExecuted,"sigc::signal<void,const std::string&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: createColouredListItem of class  EmberOgre::Gui::ColouredListItem */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ColouredListItem_new00
static int tolua_EmberOgre_EmberOgre_Gui_ColouredListItem_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ColouredListItem",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string text = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  EmberOgre::Gui::ColouredListItem::createColouredListItem(text);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
   tolua_pushcppstring(tolua_S,(const char*)text);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createColouredListItem of class  EmberOgre::Gui::ColouredListItem */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ColouredListItem_new01
static int tolua_EmberOgre_EmberOgre_Gui_ColouredListItem_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ColouredListItem",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string text = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  unsigned int item_id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  {
   CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  EmberOgre::Gui::ColouredListItem::createColouredListItem(text,item_id);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
   tolua_pushcppstring(tolua_S,(const char*)text);
  }
 }
 return 2;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_ColouredListItem_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: createColouredListItem of class  EmberOgre::Gui::ColouredListItem */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ColouredListItem_new02
static int tolua_EmberOgre_EmberOgre_Gui_ColouredListItem_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ColouredListItem",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isuserdata(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string text = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  unsigned int item_id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  void* item_data = ((void*)  tolua_touserdata(tolua_S,4,0));
  {
   CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  EmberOgre::Gui::ColouredListItem::createColouredListItem(text,item_id,item_data);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
   tolua_pushcppstring(tolua_S,(const char*)text);
  }
 }
 return 2;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_ColouredListItem_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  EmberOgre::Gui::ColouredTreeItem */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ColouredTreeItem_new00
static int tolua_EmberOgre_EmberOgre_Gui_ColouredTreeItem_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ColouredTreeItem",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string text = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   CEGUI::TreeItem* tolua_ret = (CEGUI::TreeItem*)  EmberOgre::Gui::ColouredTreeItem::create(text);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TreeItem");
   tolua_pushcppstring(tolua_S,(const char*)text);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  EmberOgre::Gui::ColouredTreeItem */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ColouredTreeItem_new01
static int tolua_EmberOgre_EmberOgre_Gui_ColouredTreeItem_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ColouredTreeItem",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string text = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  unsigned int item_id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  {
   CEGUI::TreeItem* tolua_ret = (CEGUI::TreeItem*)  EmberOgre::Gui::ColouredTreeItem::create(text,item_id);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TreeItem");
   tolua_pushcppstring(tolua_S,(const char*)text);
  }
 }
 return 2;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_ColouredTreeItem_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  EmberOgre::Gui::ColouredTreeItem */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ColouredTreeItem_new02
static int tolua_EmberOgre_EmberOgre_Gui_ColouredTreeItem_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ColouredTreeItem",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isuserdata(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string text = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  unsigned int item_id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  void* item_data = ((void*)  tolua_touserdata(tolua_S,4,0));
  {
   CEGUI::TreeItem* tolua_ret = (CEGUI::TreeItem*)  EmberOgre::Gui::ColouredTreeItem::create(text,item_id,item_data);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TreeItem");
   tolua_pushcppstring(tolua_S,(const char*)text);
  }
 }
 return 2;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_ColouredTreeItem_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::TexturePair */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_TexturePair_new00
static int tolua_EmberOgre_EmberOgre_Gui_TexturePair_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::TexturePair",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::TexturePtr",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Imageset",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ogre::TexturePtr mOgreTexture = *((Ogre::TexturePtr*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Image* mTextureImage = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Imageset* mTextureImageset = ((CEGUI::Imageset*)  tolua_tousertype(tolua_S,4,0));
  {
   EmberOgre::Gui::TexturePair* tolua_ret = (EmberOgre::Gui::TexturePair*)  Mtolua_new((EmberOgre::Gui::TexturePair)(mOgreTexture,mTextureImage,mTextureImageset));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::TexturePair");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::TexturePair */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_TexturePair_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_TexturePair_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::TexturePair",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::TexturePtr",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"const CEGUI::Image",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Imageset",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ogre::TexturePtr mOgreTexture = *((Ogre::TexturePtr*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Image* mTextureImage = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Imageset* mTextureImageset = ((CEGUI::Imageset*)  tolua_tousertype(tolua_S,4,0));
  {
   EmberOgre::Gui::TexturePair* tolua_ret = (EmberOgre::Gui::TexturePair*)  Mtolua_new((EmberOgre::Gui::TexturePair)(mOgreTexture,mTextureImage,mTextureImageset));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::TexturePair");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::TexturePair */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_TexturePair_new01
static int tolua_EmberOgre_EmberOgre_Gui_TexturePair_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::TexturePair",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  {
   EmberOgre::Gui::TexturePair* tolua_ret = (EmberOgre::Gui::TexturePair*)  Mtolua_new((EmberOgre::Gui::TexturePair)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::TexturePair");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_TexturePair_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::TexturePair */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_TexturePair_new01_local
static int tolua_EmberOgre_EmberOgre_Gui_TexturePair_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::TexturePair",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  {
   EmberOgre::Gui::TexturePair* tolua_ret = (EmberOgre::Gui::TexturePair*)  Mtolua_new((EmberOgre::Gui::TexturePair)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::TexturePair");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_TexturePair_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOgreTexture of class  EmberOgre::Gui::TexturePair */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_TexturePair_getOgreTexture00
static int tolua_EmberOgre_EmberOgre_Gui_TexturePair_getOgreTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::TexturePair",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::TexturePair* self = (const EmberOgre::Gui::TexturePair*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOgreTexture'", NULL);
#endif
  {
   Ogre::TexturePtr tolua_ret = (Ogre::TexturePtr)  self->getOgreTexture();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::TexturePtr)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::TexturePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::TexturePtr));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::TexturePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOgreTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTextureImage of class  EmberOgre::Gui::TexturePair */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_TexturePair_getTextureImage00
static int tolua_EmberOgre_EmberOgre_Gui_TexturePair_getTextureImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::TexturePair",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::TexturePair* self = (const EmberOgre::Gui::TexturePair*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTextureImage'", NULL);
#endif
  {
   const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getTextureImage();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextureImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTextureImageset of class  EmberOgre::Gui::TexturePair */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_TexturePair_getTextureImageset00
static int tolua_EmberOgre_EmberOgre_Gui_TexturePair_getTextureImageset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::TexturePair",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::TexturePair* self = (const EmberOgre::Gui::TexturePair*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTextureImageset'", NULL);
#endif
  {
   CEGUI::Imageset* tolua_ret = (CEGUI::Imageset*)  self->getTextureImageset();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Imageset");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextureImageset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hasData of class  EmberOgre::Gui::TexturePair */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_TexturePair_hasData00
static int tolua_EmberOgre_EmberOgre_Gui_TexturePair_hasData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::TexturePair",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::TexturePair* self = (EmberOgre::Gui::TexturePair*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hasData'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->hasData();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hasData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::AssetsManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_AssetsManager_new00
static int tolua_EmberOgre_EmberOgre_Gui_AssetsManager_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::AssetsManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::AssetsManager* tolua_ret = (EmberOgre::Gui::AssetsManager*)  Mtolua_new((EmberOgre::Gui::AssetsManager)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::AssetsManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::AssetsManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_AssetsManager_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_AssetsManager_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::AssetsManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::AssetsManager* tolua_ret = (EmberOgre::Gui::AssetsManager*)  Mtolua_new((EmberOgre::Gui::AssetsManager)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::AssetsManager");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::AssetsManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_AssetsManager_delete00
static int tolua_EmberOgre_EmberOgre_Gui_AssetsManager_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::AssetsManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::AssetsManager* self = (EmberOgre::Gui::AssetsManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: showTexture of class  EmberOgre::Gui::AssetsManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_AssetsManager_showTexture00
static int tolua_EmberOgre_EmberOgre_Gui_AssetsManager_showTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::AssetsManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::AssetsManager* self = (EmberOgre::Gui::AssetsManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string textureName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'showTexture'", NULL);
#endif
  {
   EmberOgre::Gui::TexturePair tolua_ret = (EmberOgre::Gui::TexturePair)  self->showTexture(textureName);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((EmberOgre::Gui::TexturePair)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Gui::TexturePair");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(EmberOgre::Gui::TexturePair));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Gui::TexturePair");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'showTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createTextureImage of class  EmberOgre::Gui::AssetsManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_AssetsManager_createTextureImage00
static int tolua_EmberOgre_EmberOgre_Gui_AssetsManager_createTextureImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::AssetsManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::TexturePtr",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::AssetsManager* self = (EmberOgre::Gui::AssetsManager*)  tolua_tousertype(tolua_S,1,0);
  Ogre::TexturePtr texturePtr = *((Ogre::TexturePtr*)  tolua_tousertype(tolua_S,2,0));
  const std::string imageSetName = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createTextureImage'", NULL);
#endif
  {
   EmberOgre::Gui::TexturePair tolua_ret = (EmberOgre::Gui::TexturePair)  self->createTextureImage(texturePtr,imageSetName);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((EmberOgre::Gui::TexturePair)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Gui::TexturePair");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(EmberOgre::Gui::TexturePair));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Gui::TexturePair");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushcppstring(tolua_S,(const char*)imageSetName);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createTextureImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: materialAsText of class  EmberOgre::Gui::AssetsManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_AssetsManager_materialAsText00
static int tolua_EmberOgre_EmberOgre_Gui_AssetsManager_materialAsText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::AssetsManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::MaterialPtr",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::AssetsManager* self = (EmberOgre::Gui::AssetsManager*)  tolua_tousertype(tolua_S,1,0);
  Ogre::MaterialPtr material = *((Ogre::MaterialPtr*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'materialAsText'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->materialAsText(material);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'materialAsText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resolveResourceNameFromFilePath of class  EmberOgre::Gui::AssetsManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_AssetsManager_resolveResourceNameFromFilePath00
static int tolua_EmberOgre_EmberOgre_Gui_AssetsManager_resolveResourceNameFromFilePath00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::AssetsManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::AssetsManager* self = (EmberOgre::Gui::AssetsManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string filePath = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resolveResourceNameFromFilePath'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->resolveResourceNameFromFilePath(filePath);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)filePath);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resolveResourceNameFromFilePath'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resolveFilePathForMesh of class  EmberOgre::Gui::AssetsManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_AssetsManager_resolveFilePathForMesh00
static int tolua_EmberOgre_EmberOgre_Gui_AssetsManager_resolveFilePathForMesh00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::AssetsManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::MeshPtr",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::AssetsManager* self = (EmberOgre::Gui::AssetsManager*)  tolua_tousertype(tolua_S,1,0);
  Ogre::MeshPtr meshPtr = *((Ogre::MeshPtr*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resolveFilePathForMesh'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->resolveFilePathForMesh(meshPtr);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resolveFilePathForMesh'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: exportMesh of class  EmberOgre::Gui::AssetsManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_AssetsManager_exportMesh00
static int tolua_EmberOgre_EmberOgre_Gui_AssetsManager_exportMesh00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::AssetsManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::MeshPtr",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::AssetsManager* self = (EmberOgre::Gui::AssetsManager*)  tolua_tousertype(tolua_S,1,0);
  Ogre::MeshPtr mesh = *((Ogre::MeshPtr*)  tolua_tousertype(tolua_S,2,0));
  const std::string filePath = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'exportMesh'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->exportMesh(mesh,filePath);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)filePath);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'exportMesh'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: serialize of class  EmberOgre::Gui::AtlasHelper */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_AtlasHelper_serialize00
static int tolua_EmberOgre_EmberOgre_Gui_AtlasHelper_serialize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::AtlasHelper",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Objects::Root",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Objects::Root* obj = ((const Atlas::Objects::Root*)  tolua_tousertype(tolua_S,2,0));
  {
   std::string tolua_ret = (std::string)  EmberOgre::Gui::AtlasHelper::serialize(*obj);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'serialize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: serialize of class  EmberOgre::Gui::AtlasHelper */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_AtlasHelper_serialize01
static int tolua_EmberOgre_EmberOgre_Gui_AtlasHelper_serialize01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::AtlasHelper",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Objects::Root",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Atlas::Objects::Root* obj = ((const Atlas::Objects::Root*)  tolua_tousertype(tolua_S,2,0));
  const std::string codecType = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  {
   std::string tolua_ret = (std::string)  EmberOgre::Gui::AtlasHelper::serialize(*obj,codecType);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)codecType);
  }
 }
 return 2;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_AtlasHelper_serialize00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Compass */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Compass_new00
static int tolua_EmberOgre_EmberOgre_Gui_Compass_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Compass",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::ICompassImpl",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Ogre::SceneManager",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ICompassImpl* compassImpl = ((EmberOgre::Gui::ICompassImpl*)  tolua_tousertype(tolua_S,2,0));
  Ogre::SceneManager* sceneManager = ((Ogre::SceneManager*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Compass* tolua_ret = (EmberOgre::Gui::Compass*)  Mtolua_new((EmberOgre::Gui::Compass)(compassImpl,*sceneManager));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Compass");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Compass */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Compass_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_Compass_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Compass",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::ICompassImpl",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Ogre::SceneManager",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ICompassImpl* compassImpl = ((EmberOgre::Gui::ICompassImpl*)  tolua_tousertype(tolua_S,2,0));
  Ogre::SceneManager* sceneManager = ((Ogre::SceneManager*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Compass* tolua_ret = (EmberOgre::Gui::Compass*)  Mtolua_new((EmberOgre::Gui::Compass)(compassImpl,*sceneManager));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Compass");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Compass */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Compass_delete00
static int tolua_EmberOgre_EmberOgre_Gui_Compass_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Compass",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Compass* self = (EmberOgre::Gui::Compass*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMap of class  EmberOgre::Gui::Compass */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Compass_getMap00
static int tolua_EmberOgre_EmberOgre_Gui_Compass_getMap00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Compass",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Compass* self = (EmberOgre::Gui::Compass*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMap'", NULL);
#endif
  {
   EmberOgre::Terrain::Map& tolua_ret = (EmberOgre::Terrain::Map&)  self->getMap();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Terrain::Map");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMap'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reposition of class  EmberOgre::Gui::Compass */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Compass_reposition00
static int tolua_EmberOgre_EmberOgre_Gui_Compass_reposition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Compass",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Compass* self = (EmberOgre::Gui::Compass*)  tolua_tousertype(tolua_S,1,0);
  float x = ((float)  tolua_tonumber(tolua_S,2,0));
  float y = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reposition'", NULL);
#endif
  {
   self->reposition(x,y);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reposition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: rotate of class  EmberOgre::Gui::Compass */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Compass_rotate00
static int tolua_EmberOgre_EmberOgre_Gui_Compass_rotate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Compass",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Degree",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Compass* self = (EmberOgre::Gui::Compass*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::Degree* degree = ((const Ogre::Degree*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate'", NULL);
#endif
  {
   self->rotate(*degree);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'rotate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: rotate of class  EmberOgre::Gui::Compass */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Compass_rotate01
static int tolua_EmberOgre_EmberOgre_Gui_Compass_rotate01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Compass",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Radian",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::Gui::Compass* self = (EmberOgre::Gui::Compass*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::Radian* radian = ((const Ogre::Radian*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate'", NULL);
#endif
  {
   self->rotate(*radian);
  }
 }
 return 0;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_Compass_rotate00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: refresh of class  EmberOgre::Gui::Compass */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Compass_refresh00
static int tolua_EmberOgre_EmberOgre_Gui_Compass_refresh00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Compass",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Compass* self = (EmberOgre::Gui::Compass*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'refresh'", NULL);
#endif
  {
   self->refresh();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'refresh'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::CEGUICompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_new00
static int tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::CEGUICompassImpl",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::CEGUICompassImpl* tolua_ret = (EmberOgre::Gui::CEGUICompassImpl*)  Mtolua_new((EmberOgre::Gui::CEGUICompassImpl)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::CEGUICompassImpl");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::CEGUICompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::CEGUICompassImpl",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::CEGUICompassImpl* tolua_ret = (EmberOgre::Gui::CEGUICompassImpl*)  Mtolua_new((EmberOgre::Gui::CEGUICompassImpl)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::CEGUICompassImpl");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::CEGUICompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_delete00
static int tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::CEGUICompassImpl",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::CEGUICompassImpl* self = (EmberOgre::Gui::CEGUICompassImpl*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getViewImage of class  EmberOgre::Gui::CEGUICompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_getViewImage00
static int tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_getViewImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::CEGUICompassImpl",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::CEGUICompassImpl* self = (EmberOgre::Gui::CEGUICompassImpl*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getViewImage'", NULL);
#endif
  {
   const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getViewImage();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getViewImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::OverlayCompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_OverlayCompassImpl_new00
static int tolua_EmberOgre_EmberOgre_Gui_OverlayCompassImpl_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::OverlayCompassImpl",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::OverlayCompassImpl* tolua_ret = (EmberOgre::Gui::OverlayCompassImpl*)  Mtolua_new((EmberOgre::Gui::OverlayCompassImpl)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::OverlayCompassImpl");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::OverlayCompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_OverlayCompassImpl_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_OverlayCompassImpl_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::OverlayCompassImpl",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::OverlayCompassImpl* tolua_ret = (EmberOgre::Gui::OverlayCompassImpl*)  Mtolua_new((EmberOgre::Gui::OverlayCompassImpl)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::OverlayCompassImpl");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::OverlayCompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_OverlayCompassImpl_delete00
static int tolua_EmberOgre_EmberOgre_Gui_OverlayCompassImpl_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::OverlayCompassImpl",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::OverlayCompassImpl* self = (EmberOgre::Gui::OverlayCompassImpl*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::RenderedCompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new00
static int tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::RenderedCompassImpl",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::RenderedCompassImpl* tolua_ret = (EmberOgre::Gui::RenderedCompassImpl*)  Mtolua_new((EmberOgre::Gui::RenderedCompassImpl)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::RenderedCompassImpl");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::RenderedCompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::RenderedCompassImpl",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::RenderedCompassImpl* tolua_ret = (EmberOgre::Gui::RenderedCompassImpl*)  Mtolua_new((EmberOgre::Gui::RenderedCompassImpl)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::RenderedCompassImpl");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::RenderedCompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new01
static int tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::RenderedCompassImpl",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  std::string compassMaterialName = ((std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   EmberOgre::Gui::RenderedCompassImpl* tolua_ret = (EmberOgre::Gui::RenderedCompassImpl*)  Mtolua_new((EmberOgre::Gui::RenderedCompassImpl)(compassMaterialName));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::RenderedCompassImpl");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::RenderedCompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new01_local
static int tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::RenderedCompassImpl",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  std::string compassMaterialName = ((std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   EmberOgre::Gui::RenderedCompassImpl* tolua_ret = (EmberOgre::Gui::RenderedCompassImpl*)  Mtolua_new((EmberOgre::Gui::RenderedCompassImpl)(compassMaterialName));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::RenderedCompassImpl");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::RenderedCompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new02
static int tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::RenderedCompassImpl",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  std::string compassMaterialName = ((std::string)  tolua_tocppstring(tolua_S,2,0));
  std::string pointerMaterialName = ((std::string)  tolua_tocppstring(tolua_S,3,0));
  {
   EmberOgre::Gui::RenderedCompassImpl* tolua_ret = (EmberOgre::Gui::RenderedCompassImpl*)  Mtolua_new((EmberOgre::Gui::RenderedCompassImpl)(compassMaterialName,pointerMaterialName));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::RenderedCompassImpl");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::RenderedCompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new02_local
static int tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::RenderedCompassImpl",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  std::string compassMaterialName = ((std::string)  tolua_tocppstring(tolua_S,2,0));
  std::string pointerMaterialName = ((std::string)  tolua_tocppstring(tolua_S,3,0));
  {
   EmberOgre::Gui::RenderedCompassImpl* tolua_ret = (EmberOgre::Gui::RenderedCompassImpl*)  Mtolua_new((EmberOgre::Gui::RenderedCompassImpl)(compassMaterialName,pointerMaterialName));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::RenderedCompassImpl");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::RenderedCompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_delete00
static int tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::RenderedCompassImpl",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::RenderedCompassImpl* self = (EmberOgre::Gui::RenderedCompassImpl*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTexture of class  EmberOgre::Gui::RenderedCompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_getTexture00
static int tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_getTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::RenderedCompassImpl",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::RenderedCompassImpl* self = (const EmberOgre::Gui::RenderedCompassImpl*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTexture'", NULL);
#endif
  {
   Ogre::TexturePtr tolua_ret = (Ogre::TexturePtr)  self->getTexture();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::TexturePtr)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::TexturePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::TexturePtr));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::TexturePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPointerTexture of class  EmberOgre::Gui::RenderedCompassImpl */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_getPointerTexture00
static int tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_getPointerTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::RenderedCompassImpl",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::RenderedCompassImpl* self = (const EmberOgre::Gui::RenderedCompassImpl*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPointerTexture'", NULL);
#endif
  {
   Ogre::TexturePtr tolua_ret = (Ogre::TexturePtr)  self->getPointerTexture();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::TexturePtr)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::TexturePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::TexturePtr));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::TexturePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPointerTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::CompassCameraAnchor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CompassCameraAnchor_new00
static int tolua_EmberOgre_EmberOgre_Gui_CompassCameraAnchor_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::CompassCameraAnchor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Compass",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"Ogre::Camera",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Compass* compass = ((EmberOgre::Gui::Compass*)  tolua_tousertype(tolua_S,2,0));
  Ogre::Camera* camera = ((Ogre::Camera*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::CompassCameraAnchor* tolua_ret = (EmberOgre::Gui::CompassCameraAnchor*)  Mtolua_new((EmberOgre::Gui::CompassCameraAnchor)(*compass,camera));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::CompassCameraAnchor");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::CompassCameraAnchor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CompassCameraAnchor_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_CompassCameraAnchor_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::CompassCameraAnchor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Compass",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"Ogre::Camera",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Compass* compass = ((EmberOgre::Gui::Compass*)  tolua_tousertype(tolua_S,2,0));
  Ogre::Camera* camera = ((Ogre::Camera*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::CompassCameraAnchor* tolua_ret = (EmberOgre::Gui::CompassCameraAnchor*)  Mtolua_new((EmberOgre::Gui::CompassCameraAnchor)(*compass,camera));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::CompassCameraAnchor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::CompassCameraAnchor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CompassCameraAnchor_delete00
static int tolua_EmberOgre_EmberOgre_Gui_CompassCameraAnchor_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::CompassCameraAnchor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::CompassCameraAnchor* self = (EmberOgre::Gui::CompassCameraAnchor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::CompassSceneNodeAnchor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CompassSceneNodeAnchor_new00
static int tolua_EmberOgre_EmberOgre_Gui_CompassSceneNodeAnchor_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::CompassSceneNodeAnchor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Compass",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"Ogre::SceneNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Compass* compass = ((EmberOgre::Gui::Compass*)  tolua_tousertype(tolua_S,2,0));
  Ogre::SceneNode* sceneNode = ((Ogre::SceneNode*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::CompassSceneNodeAnchor* tolua_ret = (EmberOgre::Gui::CompassSceneNodeAnchor*)  Mtolua_new((EmberOgre::Gui::CompassSceneNodeAnchor)(*compass,sceneNode));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::CompassSceneNodeAnchor");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::CompassSceneNodeAnchor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CompassSceneNodeAnchor_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_CompassSceneNodeAnchor_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::CompassSceneNodeAnchor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Compass",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"Ogre::SceneNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Compass* compass = ((EmberOgre::Gui::Compass*)  tolua_tousertype(tolua_S,2,0));
  Ogre::SceneNode* sceneNode = ((Ogre::SceneNode*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::CompassSceneNodeAnchor* tolua_ret = (EmberOgre::Gui::CompassSceneNodeAnchor*)  Mtolua_new((EmberOgre::Gui::CompassSceneNodeAnchor)(*compass,sceneNode));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::CompassSceneNodeAnchor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::CompassSceneNodeAnchor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CompassSceneNodeAnchor_delete00
static int tolua_EmberOgre_EmberOgre_Gui_CompassSceneNodeAnchor_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::CompassSceneNodeAnchor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::CompassSceneNodeAnchor* self = (EmberOgre::Gui::CompassSceneNodeAnchor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::CompassThirdPersonCameraAnchor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CompassThirdPersonCameraAnchor_new00
static int tolua_EmberOgre_EmberOgre_Gui_CompassThirdPersonCameraAnchor_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::CompassThirdPersonCameraAnchor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Compass",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"Ogre::Camera",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"Ogre::SceneNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Compass* compass = ((EmberOgre::Gui::Compass*)  tolua_tousertype(tolua_S,2,0));
  Ogre::Camera* camera = ((Ogre::Camera*)  tolua_tousertype(tolua_S,3,0));
  Ogre::SceneNode* node = ((Ogre::SceneNode*)  tolua_tousertype(tolua_S,4,0));
  {
   EmberOgre::Gui::CompassThirdPersonCameraAnchor* tolua_ret = (EmberOgre::Gui::CompassThirdPersonCameraAnchor*)  Mtolua_new((EmberOgre::Gui::CompassThirdPersonCameraAnchor)(*compass,camera,node));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::CompassThirdPersonCameraAnchor");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::CompassThirdPersonCameraAnchor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CompassThirdPersonCameraAnchor_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_CompassThirdPersonCameraAnchor_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::CompassThirdPersonCameraAnchor",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Compass",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"Ogre::Camera",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"Ogre::SceneNode",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Compass* compass = ((EmberOgre::Gui::Compass*)  tolua_tousertype(tolua_S,2,0));
  Ogre::Camera* camera = ((Ogre::Camera*)  tolua_tousertype(tolua_S,3,0));
  Ogre::SceneNode* node = ((Ogre::SceneNode*)  tolua_tousertype(tolua_S,4,0));
  {
   EmberOgre::Gui::CompassThirdPersonCameraAnchor* tolua_ret = (EmberOgre::Gui::CompassThirdPersonCameraAnchor*)  Mtolua_new((EmberOgre::Gui::CompassThirdPersonCameraAnchor)(*compass,camera,node));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::CompassThirdPersonCameraAnchor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::CompassThirdPersonCameraAnchor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_CompassThirdPersonCameraAnchor_delete00
static int tolua_EmberOgre_EmberOgre_Gui_CompassThirdPersonCameraAnchor_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::CompassThirdPersonCameraAnchor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::CompassThirdPersonCameraAnchor* self = (EmberOgre::Gui::CompassThirdPersonCameraAnchor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_new00
static int tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Eris::TypeService",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"CEGUI::Tree",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Eris::TypeService* typeService = ((Eris::TypeService*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Tree* treeWidget = ((CEGUI::Tree*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter)(*typeService,*treeWidget));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Eris::TypeService",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"CEGUI::Tree",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Eris::TypeService* typeService = ((Eris::TypeService*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Tree* treeWidget = ((CEGUI::Tree*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter)(*typeService,*treeWidget));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_delete00
static int tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter* self = (EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initialize of class  EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_initialize00
static int tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_initialize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter* self = (EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter*)  tolua_tousertype(tolua_S,1,0);
  const std::string rootTypeName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initialize'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->initialize(rootTypeName);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)rootTypeName);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initialize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectedTypeInfo of class  EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_getSelectedTypeInfo00
static int tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_getSelectedTypeInfo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter* self = (EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectedTypeInfo'", NULL);
#endif
  {
   Eris::TypeInfo* tolua_ret = (Eris::TypeInfo*)  self->getSelectedTypeInfo();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Eris::TypeInfo");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectedTypeInfo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_new00
static int tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::ListHolder",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"Ogre::ResourceManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ListHolder* listHolder = ((EmberOgre::Gui::ListHolder*)  tolua_tousertype(tolua_S,2,0));
  Ogre::ResourceManager* resourceManager = ((Ogre::ResourceManager*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter)(listHolder,resourceManager));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::ListHolder",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"Ogre::ResourceManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ListHolder* listHolder = ((EmberOgre::Gui::ListHolder*)  tolua_tousertype(tolua_S,2,0));
  Ogre::ResourceManager* resourceManager = ((Ogre::ResourceManager*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter)(listHolder,resourceManager));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_delete00
static int tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter* self = (EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: update of class  EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_update00
static int tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_update00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter* self = (EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'update'", NULL);
#endif
  {
   self->update();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'update'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImage of class  EmberOgre::Gui::Icons::Icon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Icons_Icon_getImage00
static int tolua_EmberOgre_EmberOgre_Gui_Icons_Icon_getImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Icons::Icon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Icons::Icon* self = (EmberOgre::Gui::Icons::Icon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImage'", NULL);
#endif
  {
   const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getImage();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImage of class  EmberOgre::Gui::Icons::Icon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Icons_Icon_getImage01
static int tolua_EmberOgre_EmberOgre_Gui_Icons_Icon_getImage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Icons::Icon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const EmberOgre::Gui::Icons::Icon* self = (const EmberOgre::Gui::Icons::Icon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImage'", NULL);
#endif
  {
   const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getImage();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_Icons_Icon_getImage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Icons::IconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_new00
static int tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Icons::IconManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::Icons::IconManager* tolua_ret = (EmberOgre::Gui::Icons::IconManager*)  Mtolua_new((EmberOgre::Gui::Icons::IconManager)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Icons::IconManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Icons::IconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Icons::IconManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::Icons::IconManager* tolua_ret = (EmberOgre::Gui::Icons::IconManager*)  Mtolua_new((EmberOgre::Gui::Icons::IconManager)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Icons::IconManager");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Icons::IconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_delete00
static int tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Icons::IconManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Icons::IconManager* self = (EmberOgre::Gui::Icons::IconManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIcon of class  EmberOgre::Gui::Icons::IconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_getIcon00
static int tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_getIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Icons::IconManager",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Icons::IconManager* self = (EmberOgre::Gui::Icons::IconManager*)  tolua_tousertype(tolua_S,1,0);
  int pixelWidth = ((int)  tolua_tonumber(tolua_S,2,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIcon'", NULL);
#endif
  {
   EmberOgre::Gui::Icons::Icon* tolua_ret = (EmberOgre::Gui::Icons::Icon*)  self->getIcon(pixelWidth,entity);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Icons::Icon");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIcon of class  EmberOgre::Gui::Icons::IconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_getIcon01
static int tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_getIcon01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Icons::IconManager",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"Eris::TypeInfo",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::Gui::Icons::IconManager* self = (EmberOgre::Gui::Icons::IconManager*)  tolua_tousertype(tolua_S,1,0);
  int pixelWidth = ((int)  tolua_tonumber(tolua_S,2,0));
  Eris::TypeInfo* erisType = ((Eris::TypeInfo*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIcon'", NULL);
#endif
  {
   EmberOgre::Gui::Icons::Icon* tolua_ret = (EmberOgre::Gui::Icons::Icon*)  self->getIcon(pixelWidth,erisType);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Icons::Icon");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_getIcon00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  EmberOgre::Gui::Icons::IconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_render00
static int tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_render00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Icons::IconManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Icons::Icon",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Icons::IconManager* self = (EmberOgre::Gui::Icons::IconManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::Icons::Icon* icon = ((EmberOgre::Gui::Icons::Icon*)  tolua_tousertype(tolua_S,2,0));
  const std::string modelName = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'", NULL);
#endif
  {
   self->render(*icon,modelName);
   tolua_pushcppstring(tolua_S,(const char*)modelName);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'render'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  EmberOgre::Gui::Icons::IconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_render01
static int tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_render01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Icons::IconManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Icons::Icon",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"EmberOgre::EmberEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::Gui::Icons::IconManager* self = (EmberOgre::Gui::Icons::IconManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::Icons::Icon* icon = ((EmberOgre::Gui::Icons::Icon*)  tolua_tousertype(tolua_S,2,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'", NULL);
#endif
  {
   self->render(*icon,*entity);
  }
 }
 return 0;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_render00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  EmberOgre::Gui::Icons::IconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_render02
static int tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_render02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Icons::IconManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Icons::Icon",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Eris::TypeInfo",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::Gui::Icons::IconManager* self = (EmberOgre::Gui::Icons::IconManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::Icons::Icon* icon = ((EmberOgre::Gui::Icons::Icon*)  tolua_tousertype(tolua_S,2,0));
  Eris::TypeInfo* erisType = ((Eris::TypeInfo*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'", NULL);
#endif
  {
   self->render(*icon,*erisType);
  }
 }
 return 0;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_render01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: addEntityIcon of class  EmberOgre::Gui::EntityIconSlot */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_addEntityIcon00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_addEntityIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIconSlot",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::EntityIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIconSlot* self = (EmberOgre::Gui::EntityIconSlot*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::EntityIcon* icon = ((EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addEntityIcon'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->addEntityIcon(icon);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addEntityIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeEntityIcon of class  EmberOgre::Gui::EntityIconSlot */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_removeEntityIcon00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_removeEntityIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIconSlot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIconSlot* self = (EmberOgre::Gui::EntityIconSlot*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeEntityIcon'", NULL);
#endif
  {
   EmberOgre::Gui::EntityIcon* tolua_ret = (EmberOgre::Gui::EntityIcon*)  self->removeEntityIcon();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityIcon");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeEntityIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEntityIcon of class  EmberOgre::Gui::EntityIconSlot */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_getEntityIcon00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_getEntityIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIconSlot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIconSlot* self = (EmberOgre::Gui::EntityIconSlot*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEntityIcon'", NULL);
#endif
  {
   EmberOgre::Gui::EntityIcon* tolua_ret = (EmberOgre::Gui::EntityIcon*)  self->getEntityIcon();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityIcon");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEntityIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWindow of class  EmberOgre::Gui::EntityIconSlot */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_getWindow00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_getWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIconSlot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIconSlot* self = (EmberOgre::Gui::EntityIconSlot*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWindow'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getWindow();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyIconDraggedOff of class  EmberOgre::Gui::EntityIconSlot */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_notifyIconDraggedOff00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_notifyIconDraggedOff00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIconSlot",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::EntityIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIconSlot* self = (EmberOgre::Gui::EntityIconSlot*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::EntityIcon* entityIcon = ((EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notifyIconDraggedOff'", NULL);
#endif
  {
   self->notifyIconDraggedOff(entityIcon);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'notifyIconDraggedOff'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventIconDraggedOff of class  EmberOgre::Gui::EntityIconSlot */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__EntityIconSlot_EventIconDraggedOff
static int tolua_get_EmberOgre__Gui__EntityIconSlot_EventIconDraggedOff(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconSlot* self = (EmberOgre::Gui::EntityIconSlot*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDraggedOff'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventIconDraggedOff,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventIconDraggedOff of class  EmberOgre::Gui::EntityIconSlot */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__EntityIconSlot_EventIconDraggedOff
static int tolua_set_EmberOgre__Gui__EntityIconSlot_EventIconDraggedOff(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconSlot* self = (EmberOgre::Gui::EntityIconSlot*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDraggedOff'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventIconDraggedOff = *((sigc::signal<void,EmberOgre::Gui::EntityIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImage of class  EmberOgre::Gui::EntityIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getImage00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIcon* self = (EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImage'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getImage();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDragContainer of class  EmberOgre::Gui::EntityIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getDragContainer00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getDragContainer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIcon* self = (EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDragContainer'", NULL);
#endif
  {
   CEGUI::DragContainer* tolua_ret = (CEGUI::DragContainer*)  self->getDragContainer();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::DragContainer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDragContainer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIcon of class  EmberOgre::Gui::EntityIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getIcon00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIcon* self = (EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIcon'", NULL);
#endif
  {
   EmberOgre::Gui::Icons::Icon* tolua_ret = (EmberOgre::Gui::Icons::Icon*)  self->getIcon();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Icons::Icon");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSlot of class  EmberOgre::Gui::EntityIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIcon_setSlot00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIcon_setSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIcon",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::EntityIconSlot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIcon* self = (EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::EntityIconSlot* slot = ((EmberOgre::Gui::EntityIconSlot*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSlot'", NULL);
#endif
  {
   self->setSlot(slot);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSlot of class  EmberOgre::Gui::EntityIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getSlot00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIcon* self = (EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSlot'", NULL);
#endif
  {
   EmberOgre::Gui::EntityIconSlot* tolua_ret = (EmberOgre::Gui::EntityIconSlot*)  self->getSlot();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityIconSlot");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTooltipText of class  EmberOgre::Gui::EntityIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIcon_setTooltipText00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIcon_setTooltipText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIcon",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIcon* self = (EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,1,0);
  const std::string text = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTooltipText'", NULL);
#endif
  {
   self->setTooltipText(text);
   tolua_pushcppstring(tolua_S,(const char*)text);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTooltipText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEntity of class  EmberOgre::Gui::EntityIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getEntity00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIcon* self = (EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEntity'", NULL);
#endif
  {
   EmberOgre::EmberEntity* tolua_ret = (EmberOgre::EmberEntity*)  self->getEntity();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::EmberEntity");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  EmberOgre::Gui::EntityIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIcon__eq00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIcon__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIcon",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const EmberOgre::Gui::EntityIcon",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIcon* self = (EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,1,0);
  const EmberOgre::Gui::EntityIcon* value = ((const EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator==(*value);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createSlot of class  EmberOgre::Gui::EntityIconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconManager_createSlot00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconManager_createSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIconManager",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIconManager* self = (EmberOgre::Gui::EntityIconManager*)  tolua_tousertype(tolua_S,1,0);
  unsigned int pixelSize = ((unsigned int)  tolua_tonumber(tolua_S,2,64));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createSlot'", NULL);
#endif
  {
   EmberOgre::Gui::EntityIconSlot* tolua_ret = (EmberOgre::Gui::EntityIconSlot*)  self->createSlot(pixelSize);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityIconSlot");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroySlot of class  EmberOgre::Gui::EntityIconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconManager_destroySlot00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconManager_destroySlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIconManager",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::EntityIconSlot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIconManager* self = (EmberOgre::Gui::EntityIconManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::EntityIconSlot* slot = ((EmberOgre::Gui::EntityIconSlot*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroySlot'", NULL);
#endif
  {
   self->destroySlot(slot);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroySlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createIcon of class  EmberOgre::Gui::EntityIconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconManager_createIcon00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconManager_createIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIconManager",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Icons::Icon",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIconManager* self = (EmberOgre::Gui::EntityIconManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::Icons::Icon* icon = ((EmberOgre::Gui::Icons::Icon*)  tolua_tousertype(tolua_S,2,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,3,0));
  unsigned int pixelSize = ((unsigned int)  tolua_tonumber(tolua_S,4,64));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createIcon'", NULL);
#endif
  {
   EmberOgre::Gui::EntityIcon* tolua_ret = (EmberOgre::Gui::EntityIcon*)  self->createIcon(icon,entity,pixelSize);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityIcon");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyIcon of class  EmberOgre::Gui::EntityIconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconManager_destroyIcon00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconManager_destroyIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIconManager",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::EntityIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIconManager* self = (EmberOgre::Gui::EntityIconManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::EntityIcon* icon = ((EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyIcon'", NULL);
#endif
  {
   self->destroyIcon(icon);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventIconDragStart of class  EmberOgre::Gui::EntityIconManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__EntityIconManager_EventIconDragStart
static int tolua_get_EmberOgre__Gui__EntityIconManager_EventIconDragStart(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconManager* self = (EmberOgre::Gui::EntityIconManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDragStart'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventIconDragStart,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventIconDragStart of class  EmberOgre::Gui::EntityIconManager */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__EntityIconManager_EventIconDragStart
static int tolua_set_EmberOgre__Gui__EntityIconManager_EventIconDragStart(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconManager* self = (EmberOgre::Gui::EntityIconManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDragStart'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventIconDragStart = *((sigc::signal<void,EmberOgre::Gui::EntityIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventIconDragStop of class  EmberOgre::Gui::EntityIconManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__EntityIconManager_EventIconDragStop
static int tolua_get_EmberOgre__Gui__EntityIconManager_EventIconDragStop(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconManager* self = (EmberOgre::Gui::EntityIconManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDragStop'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventIconDragStop,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventIconDragStop of class  EmberOgre::Gui::EntityIconManager */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__EntityIconManager_EventIconDragStop
static int tolua_set_EmberOgre__Gui__EntityIconManager_EventIconDragStop(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconManager* self = (EmberOgre::Gui::EntityIconManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDragStop'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventIconDragStop = *((sigc::signal<void,EmberOgre::Gui::EntityIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::EntityIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropTarget_new00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropTarget_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::EntityIconDragDropTarget",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::EntityIconDragDropTarget* tolua_ret = (EmberOgre::Gui::EntityIconDragDropTarget*)  Mtolua_new((EmberOgre::Gui::EntityIconDragDropTarget)(container));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityIconDragDropTarget");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::EntityIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropTarget_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropTarget_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::EntityIconDragDropTarget",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::EntityIconDragDropTarget* tolua_ret = (EmberOgre::Gui::EntityIconDragDropTarget*)  Mtolua_new((EmberOgre::Gui::EntityIconDragDropTarget)(container));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityIconDragDropTarget");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::EntityIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropTarget_delete00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropTarget_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIconDragDropTarget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIconDragDropTarget* self = (EmberOgre::Gui::EntityIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventIconEntered of class  EmberOgre::Gui::EntityIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__EntityIconDragDropTarget_EventIconEntered
static int tolua_get_EmberOgre__Gui__EntityIconDragDropTarget_EventIconEntered(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconDragDropTarget* self = (EmberOgre::Gui::EntityIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconEntered'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventIconEntered,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventIconEntered of class  EmberOgre::Gui::EntityIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__EntityIconDragDropTarget_EventIconEntered
static int tolua_set_EmberOgre__Gui__EntityIconDragDropTarget_EventIconEntered(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconDragDropTarget* self = (EmberOgre::Gui::EntityIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconEntered'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventIconEntered = *((sigc::signal<void,EmberOgre::Gui::EntityIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventIconLeaves of class  EmberOgre::Gui::EntityIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__EntityIconDragDropTarget_EventIconLeaves
static int tolua_get_EmberOgre__Gui__EntityIconDragDropTarget_EventIconLeaves(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconDragDropTarget* self = (EmberOgre::Gui::EntityIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconLeaves'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventIconLeaves,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventIconLeaves of class  EmberOgre::Gui::EntityIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__EntityIconDragDropTarget_EventIconLeaves
static int tolua_set_EmberOgre__Gui__EntityIconDragDropTarget_EventIconLeaves(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconDragDropTarget* self = (EmberOgre::Gui::EntityIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconLeaves'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventIconLeaves = *((sigc::signal<void,EmberOgre::Gui::EntityIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventIconDropped of class  EmberOgre::Gui::EntityIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__EntityIconDragDropTarget_EventIconDropped
static int tolua_get_EmberOgre__Gui__EntityIconDragDropTarget_EventIconDropped(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconDragDropTarget* self = (EmberOgre::Gui::EntityIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDropped'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventIconDropped,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventIconDropped of class  EmberOgre::Gui::EntityIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__EntityIconDragDropTarget_EventIconDropped
static int tolua_set_EmberOgre__Gui__EntityIconDragDropTarget_EventIconDropped(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconDragDropTarget* self = (EmberOgre::Gui::EntityIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDropped'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventIconDropped = *((sigc::signal<void,EmberOgre::Gui::EntityIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::EntityIconDragDropPreview */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_new00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::EntityIconDragDropPreview",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::EntityIconDragDropPreview* tolua_ret = (EmberOgre::Gui::EntityIconDragDropPreview*)  Mtolua_new((EmberOgre::Gui::EntityIconDragDropPreview)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityIconDragDropPreview");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::EntityIconDragDropPreview */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::EntityIconDragDropPreview",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::EntityIconDragDropPreview* tolua_ret = (EmberOgre::Gui::EntityIconDragDropPreview*)  Mtolua_new((EmberOgre::Gui::EntityIconDragDropPreview)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityIconDragDropPreview");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createPreview of class  EmberOgre::Gui::EntityIconDragDropPreview */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_createPreview00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_createPreview00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIconDragDropPreview",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::EntityIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIconDragDropPreview* self = (EmberOgre::Gui::EntityIconDragDropPreview*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::EntityIcon* icon = ((EmberOgre::Gui::EntityIcon*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createPreview'", NULL);
#endif
  {
   self->createPreview(icon);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createPreview'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: cleanupCreation of class  EmberOgre::Gui::EntityIconDragDropPreview */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_cleanupCreation00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_cleanupCreation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityIconDragDropPreview",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityIconDragDropPreview* self = (EmberOgre::Gui::EntityIconDragDropPreview*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cleanupCreation'", NULL);
#endif
  {
   self->cleanupCreation();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'cleanupCreation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDropOffset of class  EmberOgre::Gui::EntityIconDragDropPreview */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_getDropOffset00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_getDropOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::EntityIconDragDropPreview",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::EntityIconDragDropPreview* self = (const EmberOgre::Gui::EntityIconDragDropPreview*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDropOffset'", NULL);
#endif
  {
   WFMath::Vector<3> tolua_ret = (WFMath::Vector<3>)  self->getDropOffset();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((WFMath::Vector<3>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Vector<3>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(WFMath::Vector<3>));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Vector<3>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDropOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDropOrientation of class  EmberOgre::Gui::EntityIconDragDropPreview */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_getDropOrientation00
static int tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_getDropOrientation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::EntityIconDragDropPreview",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::EntityIconDragDropPreview* self = (const EmberOgre::Gui::EntityIconDragDropPreview*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDropOrientation'", NULL);
#endif
  {
   WFMath::Quaternion tolua_ret = (WFMath::Quaternion)  self->getDropOrientation();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((WFMath::Quaternion)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Quaternion");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(WFMath::Quaternion));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Quaternion");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDropOrientation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventEntityFinalized of class  EmberOgre::Gui::EntityIconDragDropPreview */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__EntityIconDragDropPreview_EventEntityFinalized
static int tolua_get_EmberOgre__Gui__EntityIconDragDropPreview_EventEntityFinalized(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconDragDropPreview* self = (EmberOgre::Gui::EntityIconDragDropPreview*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventEntityFinalized'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventEntityFinalized,"sigc::signal<void,EmberOgre::EmberEntity*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventEntityFinalized of class  EmberOgre::Gui::EntityIconDragDropPreview */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__EntityIconDragDropPreview_EventEntityFinalized
static int tolua_set_EmberOgre__Gui__EntityIconDragDropPreview_EventEntityFinalized(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityIconDragDropPreview* self = (EmberOgre::Gui::EntityIconDragDropPreview*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventEntityFinalized'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::EmberEntity*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventEntityFinalized = *((sigc::signal<void,EmberOgre::EmberEntity*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::HelpMessage */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new00
static int tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::HelpMessage",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string title = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string message = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string tags = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  {
   EmberOgre::Gui::HelpMessage* tolua_ret = (EmberOgre::Gui::HelpMessage*)  Mtolua_new((EmberOgre::Gui::HelpMessage)(title,message,tags));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::HelpMessage");
   tolua_pushcppstring(tolua_S,(const char*)title);
   tolua_pushcppstring(tolua_S,(const char*)message);
   tolua_pushcppstring(tolua_S,(const char*)tags);
  }
 }
 return 4;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::HelpMessage */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::HelpMessage",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string title = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string message = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string tags = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  {
   EmberOgre::Gui::HelpMessage* tolua_ret = (EmberOgre::Gui::HelpMessage*)  Mtolua_new((EmberOgre::Gui::HelpMessage)(title,message,tags));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::HelpMessage");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)title);
   tolua_pushcppstring(tolua_S,(const char*)message);
   tolua_pushcppstring(tolua_S,(const char*)tags);
  }
 }
 return 4;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::HelpMessage */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new01
static int tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::HelpMessage",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string title = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string message = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string tags = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  const std::string id = ((const std::string)  tolua_tocppstring(tolua_S,5,0));
  {
   EmberOgre::Gui::HelpMessage* tolua_ret = (EmberOgre::Gui::HelpMessage*)  Mtolua_new((EmberOgre::Gui::HelpMessage)(title,message,tags,id));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::HelpMessage");
   tolua_pushcppstring(tolua_S,(const char*)title);
   tolua_pushcppstring(tolua_S,(const char*)message);
   tolua_pushcppstring(tolua_S,(const char*)tags);
   tolua_pushcppstring(tolua_S,(const char*)id);
  }
 }
 return 5;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::HelpMessage */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new01_local
static int tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::HelpMessage",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string title = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string message = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string tags = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  const std::string id = ((const std::string)  tolua_tocppstring(tolua_S,5,0));
  {
   EmberOgre::Gui::HelpMessage* tolua_ret = (EmberOgre::Gui::HelpMessage*)  Mtolua_new((EmberOgre::Gui::HelpMessage)(title,message,tags,id));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::HelpMessage");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)title);
   tolua_pushcppstring(tolua_S,(const char*)message);
   tolua_pushcppstring(tolua_S,(const char*)tags);
   tolua_pushcppstring(tolua_S,(const char*)id);
  }
 }
 return 5;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHelp of class  EmberOgre::Gui::HelpMessage */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_HelpMessage_getHelp00
static int tolua_EmberOgre_EmberOgre_Gui_HelpMessage_getHelp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::HelpMessage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::HelpMessage* self = (const EmberOgre::Gui::HelpMessage*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHelp'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getHelp();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHelp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getId of class  EmberOgre::Gui::HelpMessage */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_HelpMessage_getId00
static int tolua_EmberOgre_EmberOgre_Gui_HelpMessage_getId00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::HelpMessage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::HelpMessage* self = (const EmberOgre::Gui::HelpMessage*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getId'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getId();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getId'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTags of class  EmberOgre::Gui::HelpMessage */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_HelpMessage_getTags00
static int tolua_EmberOgre_EmberOgre_Gui_HelpMessage_getTags00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::HelpMessage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::HelpMessage* self = (const EmberOgre::Gui::HelpMessage*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTags'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getTags();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTags'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTitle of class  EmberOgre::Gui::HelpMessage */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_HelpMessage_getTitle00
static int tolua_EmberOgre_EmberOgre_Gui_HelpMessage_getTitle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::HelpMessage",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::HelpMessage* self = (const EmberOgre::Gui::HelpMessage*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTitle'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getTitle();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTitle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  EmberOgre::Gui::QuickHelp */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuickHelp_getSingleton00
static int tolua_EmberOgre_EmberOgre_Gui_QuickHelp_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::QuickHelp",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::QuickHelp& tolua_ret = (EmberOgre::Gui::QuickHelp&)  EmberOgre::Gui::QuickHelp::getSingleton();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Gui::QuickHelp");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: updateText of class  EmberOgre::Gui::QuickHelp */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuickHelp_updateText00
static int tolua_EmberOgre_EmberOgre_Gui_QuickHelp_updateText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::QuickHelp",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const EmberOgre::Gui::HelpMessage",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::QuickHelp* self = (EmberOgre::Gui::QuickHelp*)  tolua_tousertype(tolua_S,1,0);
  const EmberOgre::Gui::HelpMessage* message = ((const EmberOgre::Gui::HelpMessage*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'updateText'", NULL);
#endif
  {
   self->updateText(*message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'updateText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: showWidget of class  EmberOgre::Gui::QuickHelp */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuickHelp_showWidget00
static int tolua_EmberOgre_EmberOgre_Gui_QuickHelp_showWidget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::QuickHelp",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::QuickHelp* self = (const EmberOgre::Gui::QuickHelp*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'showWidget'", NULL);
#endif
  {
   self->showWidget();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'showWidget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventToggleWidgetVisibility of class  EmberOgre::Gui::QuickHelp */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__QuickHelp_EventToggleWidgetVisibility
static int tolua_get_EmberOgre__Gui__QuickHelp_EventToggleWidgetVisibility(lua_State* tolua_S)
{
  EmberOgre::Gui::QuickHelp* self = (EmberOgre::Gui::QuickHelp*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventToggleWidgetVisibility'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventToggleWidgetVisibility,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventToggleWidgetVisibility of class  EmberOgre::Gui::QuickHelp */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__QuickHelp_EventToggleWidgetVisibility
static int tolua_set_EmberOgre__Gui__QuickHelp_EventToggleWidgetVisibility(lua_State* tolua_S)
{
  EmberOgre::Gui::QuickHelp* self = (EmberOgre::Gui::QuickHelp*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventToggleWidgetVisibility'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventToggleWidgetVisibility = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::QuickHelpCursor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_new00
static int tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::QuickHelpCursor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::QuickHelpCursor* tolua_ret = (EmberOgre::Gui::QuickHelpCursor*)  Mtolua_new((EmberOgre::Gui::QuickHelpCursor)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::QuickHelpCursor");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::QuickHelpCursor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::QuickHelpCursor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Gui::QuickHelpCursor* tolua_ret = (EmberOgre::Gui::QuickHelpCursor*)  Mtolua_new((EmberOgre::Gui::QuickHelpCursor)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::QuickHelpCursor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: nextMessage of class  EmberOgre::Gui::QuickHelpCursor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_nextMessage00
static int tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_nextMessage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::QuickHelpCursor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::QuickHelpCursor* self = (EmberOgre::Gui::QuickHelpCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'nextMessage'", NULL);
#endif
  {
   self->nextMessage();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'nextMessage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: previousMessage of class  EmberOgre::Gui::QuickHelpCursor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_previousMessage00
static int tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_previousMessage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::QuickHelpCursor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::QuickHelpCursor* self = (EmberOgre::Gui::QuickHelpCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'previousMessage'", NULL);
#endif
  {
   self->previousMessage();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'previousMessage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSize of class  EmberOgre::Gui::QuickHelpCursor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_getSize00
static int tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_getSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::QuickHelpCursor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::QuickHelpCursor* self = (const EmberOgre::Gui::QuickHelpCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSize'", NULL);
#endif
  {
   const int tolua_ret = (const int)  self->getSize();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCursorLocation of class  EmberOgre::Gui::QuickHelpCursor */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_getCursorLocation00
static int tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_getCursorLocation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::QuickHelpCursor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::QuickHelpCursor* self = (const EmberOgre::Gui::QuickHelpCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCursorLocation'", NULL);
#endif
  {
   const int tolua_ret = (const int)  self->getCursorLocation();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCursorLocation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventUpdateText of class  EmberOgre::Gui::QuickHelpCursor */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__QuickHelpCursor_EventUpdateText
static int tolua_get_EmberOgre__Gui__QuickHelpCursor_EventUpdateText(lua_State* tolua_S)
{
  EmberOgre::Gui::QuickHelpCursor* self = (EmberOgre::Gui::QuickHelpCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventUpdateText'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventUpdateText,"sigc::signal<void,const EmberOgre::Gui::HelpMessage&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::ActionBarInput */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarInput_new00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarInput_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ActionBarInput",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string actionBarNum = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   EmberOgre::Gui::ActionBarInput* tolua_ret = (EmberOgre::Gui::ActionBarInput*)  Mtolua_new((EmberOgre::Gui::ActionBarInput)(actionBarNum));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ActionBarInput");
   tolua_pushcppstring(tolua_S,(const char*)actionBarNum);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::ActionBarInput */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarInput_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarInput_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ActionBarInput",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string actionBarNum = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   EmberOgre::Gui::ActionBarInput* tolua_ret = (EmberOgre::Gui::ActionBarInput*)  Mtolua_new((EmberOgre::Gui::ActionBarInput)(actionBarNum));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ActionBarInput");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)actionBarNum);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::ActionBarInput */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarInput_delete00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarInput_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarInput",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarInput* self = (EmberOgre::Gui::ActionBarInput*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventGotHotkeyInput of class  EmberOgre::Gui::ActionBarInput */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__ActionBarInput_EventGotHotkeyInput
static int tolua_get_EmberOgre__Gui__ActionBarInput_EventGotHotkeyInput(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarInput* self = (EmberOgre::Gui::ActionBarInput*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventGotHotkeyInput'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventGotHotkeyInput,"sigc::signal<void,const std::string&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTooltipWindow of class  EmberOgre::Gui::EntityTooltip */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityTooltip_getTooltipWindow00
static int tolua_EmberOgre_EmberOgre_Gui_EntityTooltip_getTooltipWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::EntityTooltip",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::EntityTooltip* self = (const EmberOgre::Gui::EntityTooltip*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTooltipWindow'", NULL);
#endif
  {
   CEGUI::Tooltip& tolua_ret = (CEGUI::Tooltip&)  self->getTooltipWindow();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Tooltip");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTooltipWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addActionBarIcon of class  EmberOgre::Gui::ActionBarIconSlot */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_addActionBarIcon00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_addActionBarIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIconSlot",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::ActionBarIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIconSlot* self = (EmberOgre::Gui::ActionBarIconSlot*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::ActionBarIcon* icon = ((EmberOgre::Gui::ActionBarIcon*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addActionBarIcon'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->addActionBarIcon(icon);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addActionBarIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeActionBarIcon of class  EmberOgre::Gui::ActionBarIconSlot */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_removeActionBarIcon00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_removeActionBarIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIconSlot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIconSlot* self = (EmberOgre::Gui::ActionBarIconSlot*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeActionBarIcon'", NULL);
#endif
  {
   EmberOgre::Gui::ActionBarIcon* tolua_ret = (EmberOgre::Gui::ActionBarIcon*)  self->removeActionBarIcon();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ActionBarIcon");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeActionBarIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getActionBarIcon of class  EmberOgre::Gui::ActionBarIconSlot */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_getActionBarIcon00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_getActionBarIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIconSlot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIconSlot* self = (EmberOgre::Gui::ActionBarIconSlot*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getActionBarIcon'", NULL);
#endif
  {
   EmberOgre::Gui::ActionBarIcon* tolua_ret = (EmberOgre::Gui::ActionBarIcon*)  self->getActionBarIcon();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ActionBarIcon");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getActionBarIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWindow of class  EmberOgre::Gui::ActionBarIconSlot */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_getWindow00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_getWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIconSlot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIconSlot* self = (EmberOgre::Gui::ActionBarIconSlot*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWindow'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getWindow();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyIconDraggedOff of class  EmberOgre::Gui::ActionBarIconSlot */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_notifyIconDraggedOff00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_notifyIconDraggedOff00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIconSlot",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::ActionBarIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIconSlot* self = (EmberOgre::Gui::ActionBarIconSlot*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::ActionBarIcon* entityIcon = ((EmberOgre::Gui::ActionBarIcon*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notifyIconDraggedOff'", NULL);
#endif
  {
   self->notifyIconDraggedOff(entityIcon);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'notifyIconDraggedOff'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventIconDraggedOff of class  EmberOgre::Gui::ActionBarIconSlot */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__ActionBarIconSlot_EventIconDraggedOff
static int tolua_get_EmberOgre__Gui__ActionBarIconSlot_EventIconDraggedOff(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconSlot* self = (EmberOgre::Gui::ActionBarIconSlot*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDraggedOff'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventIconDraggedOff,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventIconDraggedOff of class  EmberOgre::Gui::ActionBarIconSlot */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__ActionBarIconSlot_EventIconDraggedOff
static int tolua_set_EmberOgre__Gui__ActionBarIconSlot_EventIconDraggedOff(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconSlot* self = (EmberOgre::Gui::ActionBarIconSlot*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDraggedOff'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventIconDraggedOff = *((sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImage of class  EmberOgre::Gui::ActionBarIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_getImage00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_getImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIcon* self = (EmberOgre::Gui::ActionBarIcon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImage'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getImage();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDragContainer of class  EmberOgre::Gui::ActionBarIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_getDragContainer00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_getDragContainer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIcon* self = (EmberOgre::Gui::ActionBarIcon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDragContainer'", NULL);
#endif
  {
   CEGUI::DragContainer* tolua_ret = (CEGUI::DragContainer*)  self->getDragContainer();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::DragContainer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDragContainer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIcon of class  EmberOgre::Gui::ActionBarIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_getIcon00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_getIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIcon* self = (EmberOgre::Gui::ActionBarIcon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIcon'", NULL);
#endif
  {
   EmberOgre::Gui::Icons::Icon* tolua_ret = (EmberOgre::Gui::Icons::Icon*)  self->getIcon();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Icons::Icon");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSlot of class  EmberOgre::Gui::ActionBarIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_setSlot00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_setSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIcon",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::ActionBarIconSlot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIcon* self = (EmberOgre::Gui::ActionBarIcon*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::ActionBarIconSlot* slot = ((EmberOgre::Gui::ActionBarIconSlot*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSlot'", NULL);
#endif
  {
   self->setSlot(slot);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSlot of class  EmberOgre::Gui::ActionBarIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_getSlot00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_getSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIcon* self = (EmberOgre::Gui::ActionBarIcon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSlot'", NULL);
#endif
  {
   EmberOgre::Gui::ActionBarIconSlot* tolua_ret = (EmberOgre::Gui::ActionBarIconSlot*)  self->getSlot();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ActionBarIconSlot");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTooltipText of class  EmberOgre::Gui::ActionBarIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_setTooltipText00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_setTooltipText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIcon",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIcon* self = (EmberOgre::Gui::ActionBarIcon*)  tolua_tousertype(tolua_S,1,0);
  const std::string text = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTooltipText'", NULL);
#endif
  {
   self->setTooltipText(text);
   tolua_pushcppstring(tolua_S,(const char*)text);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTooltipText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  EmberOgre::Gui::ActionBarIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon__eq00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIcon",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const EmberOgre::Gui::ActionBarIcon",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIcon* self = (EmberOgre::Gui::ActionBarIcon*)  tolua_tousertype(tolua_S,1,0);
  const EmberOgre::Gui::ActionBarIcon* value = ((const EmberOgre::Gui::ActionBarIcon*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator==(*value);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: defaultAction of class  EmberOgre::Gui::ActionBarIcon */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_defaultAction00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_defaultAction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIcon* self = (EmberOgre::Gui::ActionBarIcon*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'defaultAction'", NULL);
#endif
  {
   self->defaultAction();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'defaultAction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  AvatarIdType */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_AvatarIdType_new00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_AvatarIdType_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ActionBarIconManager::AvatarIdType",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Eris::ServerInfo",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Eris::ServerInfo* serverInfo = ((Eris::ServerInfo*)  tolua_tousertype(tolua_S,2,0));
  std::string avatarId = ((std::string)  tolua_tocppstring(tolua_S,3,0));
  {
   EmberOgre::Gui::ActionBarIconManager::AvatarIdType* tolua_ret = (EmberOgre::Gui::ActionBarIconManager::AvatarIdType*)  Mtolua_new((EmberOgre::Gui::ActionBarIconManager::AvatarIdType)(*serverInfo,avatarId));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ActionBarIconManager::AvatarIdType");
   tolua_pushcppstring(tolua_S,(const char*)avatarId);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  AvatarIdType */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_AvatarIdType_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_AvatarIdType_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ActionBarIconManager::AvatarIdType",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Eris::ServerInfo",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Eris::ServerInfo* serverInfo = ((Eris::ServerInfo*)  tolua_tousertype(tolua_S,2,0));
  std::string avatarId = ((std::string)  tolua_tocppstring(tolua_S,3,0));
  {
   EmberOgre::Gui::ActionBarIconManager::AvatarIdType* tolua_ret = (EmberOgre::Gui::ActionBarIconManager::AvatarIdType*)  Mtolua_new((EmberOgre::Gui::ActionBarIconManager::AvatarIdType)(*serverInfo,avatarId));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ActionBarIconManager::AvatarIdType");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)avatarId);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createSlot of class  EmberOgre::Gui::ActionBarIconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_createSlot00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_createSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIconManager",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIconManager* self = (EmberOgre::Gui::ActionBarIconManager*)  tolua_tousertype(tolua_S,1,0);
  unsigned int pixelSize = ((unsigned int)  tolua_tonumber(tolua_S,2,64));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createSlot'", NULL);
#endif
  {
   EmberOgre::Gui::ActionBarIconSlot* tolua_ret = (EmberOgre::Gui::ActionBarIconSlot*)  self->createSlot(pixelSize);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ActionBarIconSlot");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroySlot of class  EmberOgre::Gui::ActionBarIconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_destroySlot00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_destroySlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIconManager",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::ActionBarIconSlot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIconManager* self = (EmberOgre::Gui::ActionBarIconManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::ActionBarIconSlot* slot = ((EmberOgre::Gui::ActionBarIconSlot*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroySlot'", NULL);
#endif
  {
   self->destroySlot(slot);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroySlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createIcon of class  EmberOgre::Gui::ActionBarIconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_createIcon00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_createIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIconManager",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Icons::Icon",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIconManager* self = (EmberOgre::Gui::ActionBarIconManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::Icons::Icon* icon = ((EmberOgre::Gui::Icons::Icon*)  tolua_tousertype(tolua_S,2,0));
  unsigned int pixelSize = ((unsigned int)  tolua_tonumber(tolua_S,3,64));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createIcon'", NULL);
#endif
  {
   EmberOgre::Gui::ActionBarIcon* tolua_ret = (EmberOgre::Gui::ActionBarIcon*)  self->createIcon(icon,pixelSize);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ActionBarIcon");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyIcon of class  EmberOgre::Gui::ActionBarIconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_destroyIcon00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_destroyIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIconManager",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::ActionBarIcon",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIconManager* self = (EmberOgre::Gui::ActionBarIconManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::ActionBarIcon* icon = ((EmberOgre::Gui::ActionBarIcon*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyIcon'", NULL);
#endif
  {
   self->destroyIcon(icon);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSavedValue of class  EmberOgre::Gui::ActionBarIconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_getSavedValue00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_getSavedValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::ActionBarIconManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const EmberOgre::Gui::ActionBarIconManager::AvatarIdType",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::ActionBarIconManager* self = (const EmberOgre::Gui::ActionBarIconManager*)  tolua_tousertype(tolua_S,1,0);
  const EmberOgre::Gui::ActionBarIconManager::AvatarIdType* avatarId = ((const EmberOgre::Gui::ActionBarIconManager::AvatarIdType*)  tolua_tousertype(tolua_S,2,0));
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSavedValue'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getSavedValue(*avatarId,name);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSavedValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: saveValue of class  EmberOgre::Gui::ActionBarIconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_saveValue00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_saveValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIconManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const EmberOgre::Gui::ActionBarIconManager::AvatarIdType",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIconManager* self = (EmberOgre::Gui::ActionBarIconManager*)  tolua_tousertype(tolua_S,1,0);
  const EmberOgre::Gui::ActionBarIconManager::AvatarIdType* avatarId = ((const EmberOgre::Gui::ActionBarIconManager::AvatarIdType*)  tolua_tousertype(tolua_S,2,0));
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string value = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'saveValue'", NULL);
#endif
  {
   self->saveValue(*avatarId,key,value);
   tolua_pushcppstring(tolua_S,(const char*)key);
   tolua_pushcppstring(tolua_S,(const char*)value);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'saveValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: eraseValue of class  EmberOgre::Gui::ActionBarIconManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_eraseValue00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_eraseValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIconManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const EmberOgre::Gui::ActionBarIconManager::AvatarIdType",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIconManager* self = (EmberOgre::Gui::ActionBarIconManager*)  tolua_tousertype(tolua_S,1,0);
  const EmberOgre::Gui::ActionBarIconManager::AvatarIdType* avatarId = ((const EmberOgre::Gui::ActionBarIconManager::AvatarIdType*)  tolua_tousertype(tolua_S,2,0));
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'eraseValue'", NULL);
#endif
  {
   self->eraseValue(*avatarId,key);
   tolua_pushcppstring(tolua_S,(const char*)key);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'eraseValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventIconDragStart of class  EmberOgre::Gui::ActionBarIconManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__ActionBarIconManager_EventIconDragStart
static int tolua_get_EmberOgre__Gui__ActionBarIconManager_EventIconDragStart(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconManager* self = (EmberOgre::Gui::ActionBarIconManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDragStart'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventIconDragStart,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventIconDragStart of class  EmberOgre::Gui::ActionBarIconManager */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__ActionBarIconManager_EventIconDragStart
static int tolua_set_EmberOgre__Gui__ActionBarIconManager_EventIconDragStart(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconManager* self = (EmberOgre::Gui::ActionBarIconManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDragStart'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventIconDragStart = *((sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventIconDragStop of class  EmberOgre::Gui::ActionBarIconManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__ActionBarIconManager_EventIconDragStop
static int tolua_get_EmberOgre__Gui__ActionBarIconManager_EventIconDragStop(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconManager* self = (EmberOgre::Gui::ActionBarIconManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDragStop'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventIconDragStop,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventIconDragStop of class  EmberOgre::Gui::ActionBarIconManager */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__ActionBarIconManager_EventIconDragStop
static int tolua_set_EmberOgre__Gui__ActionBarIconManager_EventIconDragStop(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconManager* self = (EmberOgre::Gui::ActionBarIconManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconDragStop'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventIconDragStop = *((sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::ActionBarIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconDragDropTarget_new00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconDragDropTarget_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ActionBarIconDragDropTarget",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::ActionBarIconDragDropTarget* tolua_ret = (EmberOgre::Gui::ActionBarIconDragDropTarget*)  Mtolua_new((EmberOgre::Gui::ActionBarIconDragDropTarget)(container));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ActionBarIconDragDropTarget");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::ActionBarIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconDragDropTarget_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconDragDropTarget_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ActionBarIconDragDropTarget",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::ActionBarIconDragDropTarget* tolua_ret = (EmberOgre::Gui::ActionBarIconDragDropTarget*)  Mtolua_new((EmberOgre::Gui::ActionBarIconDragDropTarget)(container));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ActionBarIconDragDropTarget");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::ActionBarIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ActionBarIconDragDropTarget_delete00
static int tolua_EmberOgre_EmberOgre_Gui_ActionBarIconDragDropTarget_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ActionBarIconDragDropTarget",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ActionBarIconDragDropTarget* self = (EmberOgre::Gui::ActionBarIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventIconEntered of class  EmberOgre::Gui::ActionBarIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__ActionBarIconDragDropTarget_EventIconEntered
static int tolua_get_EmberOgre__Gui__ActionBarIconDragDropTarget_EventIconEntered(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconDragDropTarget* self = (EmberOgre::Gui::ActionBarIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconEntered'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventIconEntered,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventIconEntered of class  EmberOgre::Gui::ActionBarIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__ActionBarIconDragDropTarget_EventIconEntered
static int tolua_set_EmberOgre__Gui__ActionBarIconDragDropTarget_EventIconEntered(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconDragDropTarget* self = (EmberOgre::Gui::ActionBarIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconEntered'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventIconEntered = *((sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventIconLeaves of class  EmberOgre::Gui::ActionBarIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__ActionBarIconDragDropTarget_EventIconLeaves
static int tolua_get_EmberOgre__Gui__ActionBarIconDragDropTarget_EventIconLeaves(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconDragDropTarget* self = (EmberOgre::Gui::ActionBarIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconLeaves'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventIconLeaves,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventIconLeaves of class  EmberOgre::Gui::ActionBarIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__ActionBarIconDragDropTarget_EventIconLeaves
static int tolua_set_EmberOgre__Gui__ActionBarIconDragDropTarget_EventIconLeaves(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconDragDropTarget* self = (EmberOgre::Gui::ActionBarIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventIconLeaves'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventIconLeaves = *((sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventActionBarIconDropped of class  EmberOgre::Gui::ActionBarIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__ActionBarIconDragDropTarget_EventActionBarIconDropped
static int tolua_get_EmberOgre__Gui__ActionBarIconDragDropTarget_EventActionBarIconDropped(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconDragDropTarget* self = (EmberOgre::Gui::ActionBarIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventActionBarIconDropped'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventActionBarIconDropped,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventActionBarIconDropped of class  EmberOgre::Gui::ActionBarIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__ActionBarIconDragDropTarget_EventActionBarIconDropped
static int tolua_set_EmberOgre__Gui__ActionBarIconDragDropTarget_EventActionBarIconDropped(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconDragDropTarget* self = (EmberOgre::Gui::ActionBarIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventActionBarIconDropped'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventActionBarIconDropped = *((sigc::signal<void,EmberOgre::Gui::ActionBarIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventEntityIconDropped of class  EmberOgre::Gui::ActionBarIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__ActionBarIconDragDropTarget_EventEntityIconDropped
static int tolua_get_EmberOgre__Gui__ActionBarIconDragDropTarget_EventEntityIconDropped(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconDragDropTarget* self = (EmberOgre::Gui::ActionBarIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventEntityIconDropped'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventEntityIconDropped,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventEntityIconDropped of class  EmberOgre::Gui::ActionBarIconDragDropTarget */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__ActionBarIconDragDropTarget_EventEntityIconDropped
static int tolua_set_EmberOgre__Gui__ActionBarIconDragDropTarget_EventEntityIconDropped(lua_State* tolua_S)
{
  EmberOgre::Gui::ActionBarIconDragDropTarget* self = (EmberOgre::Gui::ActionBarIconDragDropTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventEntityIconDropped'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Gui::EntityIcon*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventEntityIconDropped = *((sigc::signal<void,EmberOgre::Gui::EntityIcon*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: createModel of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_createModel00
static int tolua_EmberOgre_EmberOgre_Model_Model_createModel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Model::Model",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::SceneManager",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ogre::SceneManager* sceneManager = ((Ogre::SceneManager*)  tolua_tousertype(tolua_S,2,0));
  const std::string modelType = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  {
   EmberOgre::Model::Model* tolua_ret = (EmberOgre::Model::Model*)  EmberOgre::Model::Model::createModel(*sceneManager,modelType);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::Model");
   tolua_pushcppstring(tolua_S,(const char*)modelType);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createModel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createModel of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_createModel01
static int tolua_EmberOgre_EmberOgre_Model_Model_createModel01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Model::Model",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::SceneManager",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Ogre::SceneManager* sceneManager = ((Ogre::SceneManager*)  tolua_tousertype(tolua_S,2,0));
  const std::string modelType = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  {
   EmberOgre::Model::Model* tolua_ret = (EmberOgre::Model::Model*)  EmberOgre::Model::Model::createModel(*sceneManager,modelType,name);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::Model");
   tolua_pushcppstring(tolua_S,(const char*)modelType);
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 3;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Model_Model_createModel00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: reload of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_reload00
static int tolua_EmberOgre_EmberOgre_Model_Model_reload00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::Model* self = (EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reload'", NULL);
#endif
  {
   self->reload();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reload'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_delete00
static int tolua_EmberOgre_EmberOgre_Model_Model_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::Model* self = (EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addSubmodel of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_addSubmodel00
static int tolua_EmberOgre_EmberOgre_Model_Model_addSubmodel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Model::SubModel",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::Model* self = (EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::SubModel* submodel = ((EmberOgre::Model::SubModel*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addSubmodel'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->addSubmodel(submodel);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addSubmodel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeSubmodel of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_removeSubmodel00
static int tolua_EmberOgre_EmberOgre_Model_Model_removeSubmodel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Model::SubModel",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::Model* self = (EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::SubModel* submodel = ((EmberOgre::Model::SubModel*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeSubmodel'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->removeSubmodel(submodel);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeSubmodel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAction of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_getAction00
static int tolua_EmberOgre_EmberOgre_Model_Model_getAction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::Model* self = (EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAction'", NULL);
#endif
  {
   EmberOgre::Model::Action* tolua_ret = (EmberOgre::Model::Action*)  self->getAction(name);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::Action");
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: showPart of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_showPart00
static int tolua_EmberOgre_EmberOgre_Model_Model_showPart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::Model* self = (EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
  const std::string partName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'showPart'", NULL);
#endif
  {
   self->showPart(partName);
   tolua_pushcppstring(tolua_S,(const char*)partName);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'showPart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hidePart of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_hidePart00
static int tolua_EmberOgre_EmberOgre_Model_Model_hidePart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::Model* self = (EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
  const std::string partName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hidePart'", NULL);
#endif
  {
   self->hidePart(partName);
   tolua_pushcppstring(tolua_S,(const char*)partName);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hidePart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVisible of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_setVisible00
static int tolua_EmberOgre_EmberOgre_Model_Model_setVisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::Model* self = (EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
  bool visible = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVisible'", NULL);
#endif
  {
   self->setVisible(visible);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getScale of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_getScale00
static int tolua_EmberOgre_EmberOgre_Model_Model_getScale00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::Model* self = (const EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getScale'", NULL);
#endif
  {
   const Ogre::Real tolua_ret = (const Ogre::Real)  self->getScale();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::Real)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"const Ogre::Real");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const Ogre::Real));
     tolua_pushusertype(tolua_S,tolua_obj,"const Ogre::Real");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getScale'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRotation of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_getRotation00
static int tolua_EmberOgre_EmberOgre_Model_Model_getRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::Model* self = (const EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRotation'", NULL);
#endif
  {
   const Ogre::Quaternion& tolua_ret = (const Ogre::Quaternion&)  self->getRotation();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Ogre::Quaternion");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUseScaleOf of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_getUseScaleOf00
static int tolua_EmberOgre_EmberOgre_Model_Model_getUseScaleOf00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::Model* self = (const EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUseScaleOf'", NULL);
#endif
  {
   const EmberOgre::Model::ModelDefinition::UseScaleOf tolua_ret = (const EmberOgre::Model::ModelDefinition::UseScaleOf)  self->getUseScaleOf();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUseScaleOf'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getName of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_getName00
static int tolua_EmberOgre_EmberOgre_Model_Model_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::Model* self = (const EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefinition of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_getDefinition00
static int tolua_EmberOgre_EmberOgre_Model_Model_getDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::Model* self = (const EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefinition'", NULL);
#endif
  {
   EmberOgre::Model::ModelDefnPtr tolua_ret = (EmberOgre::Model::ModelDefnPtr)  self->getDefinition();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((EmberOgre::Model::ModelDefnPtr)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Model::ModelDefnPtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(EmberOgre::Model::ModelDefnPtr));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Model::ModelDefnPtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hasAttachPoint of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_hasAttachPoint00
static int tolua_EmberOgre_EmberOgre_Model_Model_hasAttachPoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::Model* self = (const EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
  const std::string attachPoint = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hasAttachPoint'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->hasAttachPoint(attachPoint);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)attachPoint);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hasAttachPoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hasParticles of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_hasParticles00
static int tolua_EmberOgre_EmberOgre_Model_Model_hasParticles00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::Model* self = (const EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hasParticles'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->hasParticles();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hasParticles'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSubModel of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_getSubModel00
static int tolua_EmberOgre_EmberOgre_Model_Model_getSubModel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::Model* self = (EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
  unsigned int index = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSubModel'", NULL);
#endif
  {
   EmberOgre::Model::SubModel* tolua_ret = (EmberOgre::Model::SubModel*)  self->getSubModel(index);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::SubModel");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSubModel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDisplaySkeleton of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_setDisplaySkeleton00
static int tolua_EmberOgre_EmberOgre_Model_Model_setDisplaySkeleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::Model* self = (EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
  bool display = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDisplaySkeleton'", NULL);
#endif
  {
   self->setDisplaySkeleton(display);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDisplaySkeleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDisplaySkeleton of class  EmberOgre::Model::Model */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_Model_getDisplaySkeleton00
static int tolua_EmberOgre_EmberOgre_Model_Model_getDisplaySkeleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::Model* self = (const EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDisplaySkeleton'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getDisplaySkeleton();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDisplaySkeleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMovementMode of class  EmberOgre::Model::ModelRepresentation */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getMovementMode00
static int tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getMovementMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::ModelRepresentation",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::ModelRepresentation* self = (const EmberOgre::Model::ModelRepresentation*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMovementMode'", NULL);
#endif
  {
   EmberOgre::Model::ModelRepresentation::MovementMode tolua_ret = (EmberOgre::Model::ModelRepresentation::MovementMode)  self->getMovementMode();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMovementMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTypeNameForClass of class  EmberOgre::Model::ModelRepresentation */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getTypeNameForClass00
static int tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getTypeNameForClass00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Model::ModelRepresentation",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   const std::string tolua_ret = (const std::string)  EmberOgre::Model::ModelRepresentation::getTypeNameForClass();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTypeNameForClass'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEntity of class  EmberOgre::Model::ModelRepresentation */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getEntity00
static int tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::ModelRepresentation",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::ModelRepresentation* self = (const EmberOgre::Model::ModelRepresentation*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEntity'", NULL);
#endif
  {
   EmberOgre::EmberEntity& tolua_ret = (EmberOgre::EmberEntity&)  self->getEntity();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::EmberEntity");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getModel of class  EmberOgre::Model::ModelRepresentation */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getModel00
static int tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getModel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::ModelRepresentation",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::ModelRepresentation* self = (const EmberOgre::Model::ModelRepresentation*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getModel'", NULL);
#endif
  {
   EmberOgre::Model::Model& tolua_ret = (EmberOgre::Model::Model&)  self->getModel();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Model::Model");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getModel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWorldBoundingBox of class  EmberOgre::Model::ModelRepresentation */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getWorldBoundingBox00
static int tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getWorldBoundingBox00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::ModelRepresentation",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::ModelRepresentation* self = (const EmberOgre::Model::ModelRepresentation*)  tolua_tousertype(tolua_S,1,0);
  bool derive = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWorldBoundingBox'", NULL);
#endif
  {
   const Ogre::AxisAlignedBox& tolua_ret = (const Ogre::AxisAlignedBox&)  self->getWorldBoundingBox(derive);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Ogre::AxisAlignedBox");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWorldBoundingBox'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWorldBoundingSphere of class  EmberOgre::Model::ModelRepresentation */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getWorldBoundingSphere00
static int tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getWorldBoundingSphere00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::ModelRepresentation",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::ModelRepresentation* self = (const EmberOgre::Model::ModelRepresentation*)  tolua_tousertype(tolua_S,1,0);
  bool derive = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWorldBoundingSphere'", NULL);
#endif
  {
   const Ogre::Sphere& tolua_ret = (const Ogre::Sphere&)  self->getWorldBoundingSphere(derive);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Ogre::Sphere");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWorldBoundingSphere'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  EmberOgre::Model::ModelRepresentationManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelRepresentationManager_getSingleton00
static int tolua_EmberOgre_EmberOgre_Model_ModelRepresentationManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Model::ModelRepresentationManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Model::ModelRepresentationManager& tolua_ret = (EmberOgre::Model::ModelRepresentationManager&)  EmberOgre::Model::ModelRepresentationManager::getSingleton();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Model::ModelRepresentationManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getModelForEntity of class  EmberOgre::Model::ModelRepresentationManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelRepresentationManager_getModelForEntity00
static int tolua_EmberOgre_EmberOgre_Model_ModelRepresentationManager_getModelForEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::ModelRepresentationManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::EmberEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::ModelRepresentationManager* self = (const EmberOgre::Model::ModelRepresentationManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getModelForEntity'", NULL);
#endif
  {
   EmberOgre::Model::Model* tolua_ret = (EmberOgre::Model::Model*)  self->getModelForEntity(*entity);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::Model");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getModelForEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRepresentationForEntity of class  EmberOgre::Model::ModelRepresentationManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelRepresentationManager_getRepresentationForEntity00
static int tolua_EmberOgre_EmberOgre_Model_ModelRepresentationManager_getRepresentationForEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::ModelRepresentationManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::EmberEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::ModelRepresentationManager* self = (const EmberOgre::Model::ModelRepresentationManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRepresentationForEntity'", NULL);
#endif
  {
   EmberOgre::Model::ModelRepresentation* tolua_ret = (EmberOgre::Model::ModelRepresentation*)  self->getRepresentationForEntity(*entity);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::ModelRepresentation");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRepresentationForEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEntity of class  EmberOgre::Model::SubModel */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_SubModel_getEntity00
static int tolua_EmberOgre_EmberOgre_Model_SubModel_getEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::SubModel",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::SubModel* self = (const EmberOgre::Model::SubModel*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEntity'", NULL);
#endif
  {
   Ogre::Entity* tolua_ret = (Ogre::Entity*)  self->getEntity();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ogre::Entity");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Name of class  EmberOgre::Model::ViewDefinition */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Model__ViewDefinition_Name
static int tolua_get_EmberOgre__Model__ViewDefinition_Name(lua_State* tolua_S)
{
  EmberOgre::Model::ViewDefinition* self = (EmberOgre::Model::ViewDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Name of class  EmberOgre::Model::ViewDefinition */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Model__ViewDefinition_Name
static int tolua_set_EmberOgre__Model__ViewDefinition_Name(lua_State* tolua_S)
{
  EmberOgre::Model::ViewDefinition* self = (EmberOgre::Model::ViewDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rotation of class  EmberOgre::Model::ViewDefinition */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Model__ViewDefinition_Rotation
static int tolua_get_EmberOgre__Model__ViewDefinition_Rotation(lua_State* tolua_S)
{
  EmberOgre::Model::ViewDefinition* self = (EmberOgre::Model::ViewDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rotation'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->Rotation,"Ogre::Quaternion");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Rotation of class  EmberOgre::Model::ViewDefinition */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Model__ViewDefinition_Rotation
static int tolua_set_EmberOgre__Model__ViewDefinition_Rotation(lua_State* tolua_S)
{
  EmberOgre::Model::ViewDefinition* self = (EmberOgre::Model::ViewDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rotation'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::Quaternion",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Rotation = *((Ogre::Quaternion*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Distance of class  EmberOgre::Model::ViewDefinition */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Model__ViewDefinition_Distance
static int tolua_get_EmberOgre__Model__ViewDefinition_Distance(lua_State* tolua_S)
{
  EmberOgre::Model::ViewDefinition* self = (EmberOgre::Model::ViewDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Distance'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Distance);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Distance of class  EmberOgre::Model::ViewDefinition */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Model__ViewDefinition_Distance
static int tolua_set_EmberOgre__Model__ViewDefinition_Distance(lua_State* tolua_S)
{
  EmberOgre::Model::ViewDefinition* self = (EmberOgre::Model::ViewDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Distance'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Distance = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Name of class  EmberOgre::Model::AttachPointDefinition */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Model__AttachPointDefinition_Name
static int tolua_get_EmberOgre__Model__AttachPointDefinition_Name(lua_State* tolua_S)
{
  EmberOgre::Model::AttachPointDefinition* self = (EmberOgre::Model::AttachPointDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Name of class  EmberOgre::Model::AttachPointDefinition */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Model__AttachPointDefinition_Name
static int tolua_set_EmberOgre__Model__AttachPointDefinition_Name(lua_State* tolua_S)
{
  EmberOgre::Model::AttachPointDefinition* self = (EmberOgre::Model::AttachPointDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: BoneName of class  EmberOgre::Model::AttachPointDefinition */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Model__AttachPointDefinition_BoneName
static int tolua_get_EmberOgre__Model__AttachPointDefinition_BoneName(lua_State* tolua_S)
{
  EmberOgre::Model::AttachPointDefinition* self = (EmberOgre::Model::AttachPointDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'BoneName'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->BoneName);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: BoneName of class  EmberOgre::Model::AttachPointDefinition */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Model__AttachPointDefinition_BoneName
static int tolua_set_EmberOgre__Model__AttachPointDefinition_BoneName(lua_State* tolua_S)
{
  EmberOgre::Model::AttachPointDefinition* self = (EmberOgre::Model::AttachPointDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'BoneName'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->BoneName = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rotation of class  EmberOgre::Model::AttachPointDefinition */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Model__AttachPointDefinition_Rotation
static int tolua_get_EmberOgre__Model__AttachPointDefinition_Rotation(lua_State* tolua_S)
{
  EmberOgre::Model::AttachPointDefinition* self = (EmberOgre::Model::AttachPointDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rotation'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->Rotation,"Ogre::Quaternion");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Rotation of class  EmberOgre::Model::AttachPointDefinition */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Model__AttachPointDefinition_Rotation
static int tolua_set_EmberOgre__Model__AttachPointDefinition_Rotation(lua_State* tolua_S)
{
  EmberOgre::Model::AttachPointDefinition* self = (EmberOgre::Model::AttachPointDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rotation'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::Quaternion",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Rotation = *((Ogre::Quaternion*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSubEntityName of class  EmberOgre::Model::SubEntityDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_getSubEntityName00
static int tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_getSubEntityName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::SubEntityDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::SubEntityDefinition* self = (EmberOgre::Model::SubEntityDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSubEntityName'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getSubEntityName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSubEntityName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSubEntityIndex of class  EmberOgre::Model::SubEntityDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_getSubEntityIndex00
static int tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_getSubEntityIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::SubEntityDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::SubEntityDefinition* self = (EmberOgre::Model::SubEntityDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSubEntityIndex'", NULL);
#endif
  {
   unsigned int tolua_ret = (unsigned int)  self->getSubEntityIndex();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSubEntityIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMaterialName of class  EmberOgre::Model::SubEntityDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_getMaterialName00
static int tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_getMaterialName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::SubEntityDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::SubEntityDefinition* self = (EmberOgre::Model::SubEntityDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMaterialName'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getMaterialName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMaterialName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMaterialName of class  EmberOgre::Model::SubEntityDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_setMaterialName00
static int tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_setMaterialName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::SubEntityDefinition",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::SubEntityDefinition* self = (EmberOgre::Model::SubEntityDefinition*)  tolua_tousertype(tolua_S,1,0);
  std::string materialName = ((std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMaterialName'", NULL);
#endif
  {
   self->setMaterialName(materialName);
   tolua_pushcppstring(tolua_S,(const char*)materialName);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMaterialName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPartDefinition of class  EmberOgre::Model::SubEntityDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_getPartDefinition00
static int tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_getPartDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::SubEntityDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::SubEntityDefinition* self = (EmberOgre::Model::SubEntityDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPartDefinition'", NULL);
#endif
  {
   EmberOgre::Model::PartDefinition& tolua_ret = (EmberOgre::Model::PartDefinition&)  self->getPartDefinition();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Model::PartDefinition");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPartDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setName of class  EmberOgre::Model::PartDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_PartDefinition_setName00
static int tolua_EmberOgre_EmberOgre_Model_PartDefinition_setName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::PartDefinition",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::PartDefinition* self = (EmberOgre::Model::PartDefinition*)  tolua_tousertype(tolua_S,1,0);
  std::string name = ((std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setName'", NULL);
#endif
  {
   self->setName(name);
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getName of class  EmberOgre::Model::PartDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_PartDefinition_getName00
static int tolua_EmberOgre_EmberOgre_Model_PartDefinition_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::PartDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::PartDefinition* self = (EmberOgre::Model::PartDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setShow of class  EmberOgre::Model::PartDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_PartDefinition_setShow00
static int tolua_EmberOgre_EmberOgre_Model_PartDefinition_setShow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::PartDefinition",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::PartDefinition* self = (EmberOgre::Model::PartDefinition*)  tolua_tousertype(tolua_S,1,0);
  bool show = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShow'", NULL);
#endif
  {
   self->setShow(show);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getShow of class  EmberOgre::Model::PartDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_PartDefinition_getShow00
static int tolua_EmberOgre_EmberOgre_Model_PartDefinition_getShow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::PartDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::PartDefinition* self = (EmberOgre::Model::PartDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getShow'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getShow();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getShow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createSubEntityDefinition of class  EmberOgre::Model::PartDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_PartDefinition_createSubEntityDefinition00
static int tolua_EmberOgre_EmberOgre_Model_PartDefinition_createSubEntityDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::PartDefinition",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::PartDefinition* self = (EmberOgre::Model::PartDefinition*)  tolua_tousertype(tolua_S,1,0);
  std::string subEntityName = ((std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createSubEntityDefinition'", NULL);
#endif
  {
   EmberOgre::Model::SubEntityDefinition* tolua_ret = (EmberOgre::Model::SubEntityDefinition*)  self->createSubEntityDefinition(subEntityName);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::SubEntityDefinition");
   tolua_pushcppstring(tolua_S,(const char*)subEntityName);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createSubEntityDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createSubEntityDefinition of class  EmberOgre::Model::PartDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_PartDefinition_createSubEntityDefinition01
static int tolua_EmberOgre_EmberOgre_Model_PartDefinition_createSubEntityDefinition01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::PartDefinition",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::Model::PartDefinition* self = (EmberOgre::Model::PartDefinition*)  tolua_tousertype(tolua_S,1,0);
  unsigned int subEntityIndex = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createSubEntityDefinition'", NULL);
#endif
  {
   EmberOgre::Model::SubEntityDefinition* tolua_ret = (EmberOgre::Model::SubEntityDefinition*)  self->createSubEntityDefinition(subEntityIndex);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::SubEntityDefinition");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Model_PartDefinition_createSubEntityDefinition00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSubEntityDefinitions of class  EmberOgre::Model::PartDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_PartDefinition_getSubEntityDefinitions00
static int tolua_EmberOgre_EmberOgre_Model_PartDefinition_getSubEntityDefinitions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::PartDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::PartDefinition* self = (EmberOgre::Model::PartDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSubEntityDefinitions'", NULL);
#endif
  {
   std::vector<EmberOgre::Model::SubEntityDefinition*> tolua_ret = (std::vector<EmberOgre::Model::SubEntityDefinition*>)  self->getSubEntityDefinitions();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<EmberOgre::Model::SubEntityDefinition*>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<EmberOgre::Model::SubEntityDefinition*>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<EmberOgre::Model::SubEntityDefinition*>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<EmberOgre::Model::SubEntityDefinition*>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSubEntityDefinitions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeSubEntityDefinition of class  EmberOgre::Model::PartDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_PartDefinition_removeSubEntityDefinition00
static int tolua_EmberOgre_EmberOgre_Model_PartDefinition_removeSubEntityDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::PartDefinition",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Model::SubEntityDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::PartDefinition* self = (EmberOgre::Model::PartDefinition*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::SubEntityDefinition* def = ((EmberOgre::Model::SubEntityDefinition*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeSubEntityDefinition'", NULL);
#endif
  {
   self->removeSubEntityDefinition(def);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeSubEntityDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSubModelDefinition of class  EmberOgre::Model::PartDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_PartDefinition_getSubModelDefinition00
static int tolua_EmberOgre_EmberOgre_Model_PartDefinition_getSubModelDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::PartDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::PartDefinition* self = (EmberOgre::Model::PartDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSubModelDefinition'", NULL);
#endif
  {
   EmberOgre::Model::SubModelDefinition& tolua_ret = (EmberOgre::Model::SubModelDefinition&)  self->getSubModelDefinition();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Model::SubModelDefinition");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSubModelDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMeshName of class  EmberOgre::Model::SubModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_getMeshName00
static int tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_getMeshName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::SubModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::SubModelDefinition* self = (EmberOgre::Model::SubModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMeshName'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->getMeshName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMeshName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createPartDefinition of class  EmberOgre::Model::SubModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_createPartDefinition00
static int tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_createPartDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::SubModelDefinition",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::SubModelDefinition* self = (EmberOgre::Model::SubModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  std::string partname = ((std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createPartDefinition'", NULL);
#endif
  {
   EmberOgre::Model::PartDefinition* tolua_ret = (EmberOgre::Model::PartDefinition*)  self->createPartDefinition(partname);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::PartDefinition");
   tolua_pushcppstring(tolua_S,(const char*)partname);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createPartDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPartDefinitions of class  EmberOgre::Model::SubModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_getPartDefinitions00
static int tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_getPartDefinitions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::SubModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::SubModelDefinition* self = (EmberOgre::Model::SubModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPartDefinitions'", NULL);
#endif
  {
   std::vector<EmberOgre::Model::PartDefinition*> tolua_ret = (std::vector<EmberOgre::Model::PartDefinition*>)  self->getPartDefinitions();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<EmberOgre::Model::PartDefinition*>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<EmberOgre::Model::PartDefinition*>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<EmberOgre::Model::PartDefinition*>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<EmberOgre::Model::PartDefinition*>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPartDefinitions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removePartDefinition of class  EmberOgre::Model::SubModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_removePartDefinition00
static int tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_removePartDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::SubModelDefinition",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Model::PartDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::SubModelDefinition* self = (EmberOgre::Model::SubModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::PartDefinition* def = ((EmberOgre::Model::PartDefinition*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removePartDefinition'", NULL);
#endif
  {
   self->removePartDefinition(def);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removePartDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getModelDefinition of class  EmberOgre::Model::SubModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_getModelDefinition00
static int tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_getModelDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::SubModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::SubModelDefinition* self = (EmberOgre::Model::SubModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getModelDefinition'", NULL);
#endif
  {
   EmberOgre::Model::ModelDefinition& tolua_ret = (EmberOgre::Model::ModelDefinition&)  self->getModelDefinition();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Model::ModelDefinition");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getModelDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isValid of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_isValid00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_isValid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isValid'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isValid();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isValid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setValid of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setValid00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setValid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  bool valid = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValid'", NULL);
#endif
  {
   self->setValid(valid);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setValid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getScale of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getScale00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getScale00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getScale'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getScale();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getScale'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setScale of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setScale00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setScale00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  float scale = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setScale'", NULL);
#endif
  {
   self->setScale(scale);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setScale'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUseScaleOf of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getUseScaleOf00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getUseScaleOf00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUseScaleOf'", NULL);
#endif
  {
   EmberOgre::Model::ModelDefinition::UseScaleOf tolua_ret = (EmberOgre::Model::ModelDefinition::UseScaleOf)  self->getUseScaleOf();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUseScaleOf'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUseScaleOf of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setUseScaleOf00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setUseScaleOf00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::ModelDefinition::UseScaleOf useScale = ((EmberOgre::Model::ModelDefinition::UseScaleOf) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUseScaleOf'", NULL);
#endif
  {
   self->setUseScaleOf(useScale);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUseScaleOf'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTranslate of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getTranslate00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getTranslate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTranslate'", NULL);
#endif
  {
   Ogre::Vector3& tolua_ret = (Ogre::Vector3&)  self->getTranslate();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ogre::Vector3");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTranslate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTranslate of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setTranslate00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setTranslate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Vector3",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::Vector3 translate = *((const Ogre::Vector3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTranslate'", NULL);
#endif
  {
   self->setTranslate(translate);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTranslate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getShowContained of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getShowContained00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getShowContained00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::ModelDefinition* self = (const EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getShowContained'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getShowContained();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getShowContained'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setShowContained of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setShowContained00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setShowContained00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  bool show = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowContained'", NULL);
#endif
  {
   self->setShowContained(show);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowContained'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getContentOffset of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getContentOffset00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getContentOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::ModelDefinition* self = (const EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getContentOffset'", NULL);
#endif
  {
   const Ogre::Vector3& tolua_ret = (const Ogre::Vector3&)  self->getContentOffset();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Ogre::Vector3");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getContentOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setContentOffset of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setContentOffset00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setContentOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Vector3",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::Vector3* tolua_var_1 = ((const Ogre::Vector3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setContentOffset'", NULL);
#endif
  {
   self->setContentOffset(*tolua_var_1);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setContentOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRotation of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getRotation00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::ModelDefinition* self = (const EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRotation'", NULL);
#endif
  {
   const Ogre::Quaternion& tolua_ret = (const Ogre::Quaternion&)  self->getRotation();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Ogre::Quaternion");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRotation of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setRotation00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Quaternion",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::Quaternion rotation = *((const Ogre::Quaternion*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRotation'", NULL);
#endif
  {
   self->setRotation(rotation);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createSubModelDefinition of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_createSubModelDefinition00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_createSubModelDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  std::string meshname = ((std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createSubModelDefinition'", NULL);
#endif
  {
   EmberOgre::Model::SubModelDefinition* tolua_ret = (EmberOgre::Model::SubModelDefinition*)  self->createSubModelDefinition(meshname);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::SubModelDefinition");
   tolua_pushcppstring(tolua_S,(const char*)meshname);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createSubModelDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSubModelDefinitions of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getSubModelDefinitions00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getSubModelDefinitions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSubModelDefinitions'", NULL);
#endif
  {
   std::vector<EmberOgre::Model::SubModelDefinition*>& tolua_ret = (std::vector<EmberOgre::Model::SubModelDefinition*>&)  self->getSubModelDefinitions();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"std::vector<EmberOgre::Model::SubModelDefinition*>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSubModelDefinitions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeSubModelDefinition of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_removeSubModelDefinition00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_removeSubModelDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Model::SubModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::SubModelDefinition* def = ((EmberOgre::Model::SubModelDefinition*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeSubModelDefinition'", NULL);
#endif
  {
   self->removeSubModelDefinition(def);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeSubModelDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createActionDefinition of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_createActionDefinition00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_createActionDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  std::string actionname = ((std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createActionDefinition'", NULL);
#endif
  {
   EmberOgre::Model::ActionDefinition* tolua_ret = (EmberOgre::Model::ActionDefinition*)  self->createActionDefinition(actionname);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::ActionDefinition");
   tolua_pushcppstring(tolua_S,(const char*)actionname);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createActionDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getActionDefinitions of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getActionDefinitions00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getActionDefinitions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getActionDefinitions'", NULL);
#endif
  {
   std::vector<EmberOgre::Model::ActionDefinition*>& tolua_ret = (std::vector<EmberOgre::Model::ActionDefinition*>&)  self->getActionDefinitions();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"std::vector<EmberOgre::Model::ActionDefinition*>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getActionDefinitions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeActionDefinition of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_removeActionDefinition00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_removeActionDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Model::ActionDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::ActionDefinition* def = ((EmberOgre::Model::ActionDefinition*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeActionDefinition'", NULL);
#endif
  {
   self->removeActionDefinition(def);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeActionDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAttachPointsDefinitions of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getAttachPointsDefinitions00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getAttachPointsDefinitions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAttachPointsDefinitions'", NULL);
#endif
  {
   const std::vector<EmberOgre::Model::AttachPointDefinition>& tolua_ret = (const std::vector<EmberOgre::Model::AttachPointDefinition>&)  self->getAttachPointsDefinitions();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const std::vector<EmberOgre::Model::AttachPointDefinition>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAttachPointsDefinitions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createViewDefinition of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_createViewDefinition00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_createViewDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  const std::string viewname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createViewDefinition'", NULL);
#endif
  {
   EmberOgre::Model::ViewDefinition* tolua_ret = (EmberOgre::Model::ViewDefinition*)  self->createViewDefinition(viewname);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::ViewDefinition");
   tolua_pushcppstring(tolua_S,(const char*)viewname);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createViewDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getViewDefinitions of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getViewDefinitions00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getViewDefinitions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getViewDefinitions'", NULL);
#endif
  {
    const std::map<std::string,EmberOgre::Model::ViewDefinition*>& tolua_ret = (  const std::map<std::string,EmberOgre::Model::ViewDefinition*>&)  self->getViewDefinitions();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const std::map<std::string,EmberOgre::Model::ViewDefinition*>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getViewDefinitions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeViewDefinition of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_removeViewDefinition00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_removeViewDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeViewDefinition'", NULL);
#endif
  {
   self->removeViewDefinition(name);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeViewDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reloadAllInstances of class  EmberOgre::Model::ModelDefinition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinition_reloadAllInstances00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinition_reloadAllInstances00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinition* self = (EmberOgre::Model::ModelDefinition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reloadAllInstances'", NULL);
#endif
  {
   self->reloadAllInstances();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reloadAllInstances'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Model::ModelDefnPtr */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefnPtr_delete00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefnPtr_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefnPtr",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefnPtr* self = (EmberOgre::Model::ModelDefnPtr*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  EmberOgre::Model::ModelDefnPtr */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefnPtr_get00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefnPtr_get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefnPtr",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefnPtr* self = (EmberOgre::Model::ModelDefnPtr*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'", NULL);
#endif
  {
   EmberOgre::Model::ModelDefinition* tolua_ret = (EmberOgre::Model::ModelDefinition*)  self->get();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::ModelDefinition");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isValid of class  EmberOgre::TerrainPosition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_TerrainPosition_isValid00
static int tolua_EmberOgre_EmberOgre_TerrainPosition_isValid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::TerrainPosition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::TerrainPosition* self = (const EmberOgre::TerrainPosition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isValid'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isValid();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isValid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setToOrigin of class  EmberOgre::TerrainPosition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_TerrainPosition_setToOrigin00
static int tolua_EmberOgre_EmberOgre_TerrainPosition_setToOrigin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::TerrainPosition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::TerrainPosition* self = (EmberOgre::TerrainPosition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setToOrigin'", NULL);
#endif
  {
   EmberOgre::TerrainPosition& tolua_ret = (EmberOgre::TerrainPosition&)  self->setToOrigin();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::TerrainPosition");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setToOrigin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: x of class  EmberOgre::TerrainPosition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_TerrainPosition_x00
static int tolua_EmberOgre_EmberOgre_TerrainPosition_x00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::TerrainPosition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::TerrainPosition* self = (const EmberOgre::TerrainPosition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
#endif
  {
   float tolua_ret = (float)  self->x();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: x of class  EmberOgre::TerrainPosition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_TerrainPosition_x01
static int tolua_EmberOgre_EmberOgre_TerrainPosition_x01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::TerrainPosition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::TerrainPosition* self = (EmberOgre::TerrainPosition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
#endif
  {
   float tolua_ret = (float)  self->x();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_TerrainPosition_x00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: y of class  EmberOgre::TerrainPosition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_TerrainPosition_y00
static int tolua_EmberOgre_EmberOgre_TerrainPosition_y00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::TerrainPosition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::TerrainPosition* self = (const EmberOgre::TerrainPosition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
#endif
  {
   float tolua_ret = (float)  self->y();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: y of class  EmberOgre::TerrainPosition */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_TerrainPosition_y01
static int tolua_EmberOgre_EmberOgre_TerrainPosition_y01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::TerrainPosition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::TerrainPosition* self = (EmberOgre::TerrainPosition*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
#endif
  {
   float tolua_ret = (float)  self->y();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_TerrainPosition_y00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: toOgre<Ogre::Vector3 > of class  EmberOgre::Convert */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Convert_toOgre_Vector300
static int tolua_EmberOgre_EmberOgre_Convert_toOgre_Vector300(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Convert",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const WFMath::Point<2>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const WFMath::Point<2>* p = ((const WFMath::Point<2>*)  tolua_tousertype(tolua_S,2,0));
  {
   Ogre::Vector3 tolua_ret = (Ogre::Vector3)  EmberOgre::Convert::toOgre<Ogre::Vector3 >(*p);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::Vector3)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Vector3");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::Vector3));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Vector3");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toOgre_Vector3'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toOgre<Ogre::Vector2 > of class  EmberOgre::Convert */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Convert_toOgre_Vector200
static int tolua_EmberOgre_EmberOgre_Convert_toOgre_Vector200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Convert",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const WFMath::Point<2>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const WFMath::Point<2>* p = ((const WFMath::Point<2>*)  tolua_tousertype(tolua_S,2,0));
  {
   Ogre::Vector2 tolua_ret = (Ogre::Vector2)  EmberOgre::Convert::toOgre<Ogre::Vector2 >(*p);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::Vector2)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Vector2");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::Vector2));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Vector2");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toOgre_Vector2'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toOgre of class  EmberOgre::Convert */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Convert_toOgre00
static int tolua_EmberOgre_EmberOgre_Convert_toOgre00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Convert",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const WFMath::Vector<2>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const WFMath::Vector<2>* p = ((const WFMath::Vector<2>*)  tolua_tousertype(tolua_S,2,0));
  {
   Ogre::Vector2 tolua_ret = (Ogre::Vector2)  EmberOgre::Convert::toOgre(*p);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::Vector2)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Vector2");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::Vector2));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Vector2");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toOgre'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toWF<WFMath::Point<3> > of class  EmberOgre::Convert */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Convert_toWF_Point300
static int tolua_EmberOgre_EmberOgre_Convert_toWF_Point300(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Convert",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Vector3",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ogre::Vector3* p = ((const Ogre::Vector3*)  tolua_tousertype(tolua_S,2,0));
  {
   WFMath::Point<3> tolua_ret = (WFMath::Point<3>)  EmberOgre::Convert::toWF<WFMath::Point<3> >(*p);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((WFMath::Point<3>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Point<3>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(WFMath::Point<3>));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Point<3>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toWF_Point3'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toWF<WFMath::Point<2> > of class  EmberOgre::Convert */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Convert_toWF_Point200
static int tolua_EmberOgre_EmberOgre_Convert_toWF_Point200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Convert",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Vector3",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ogre::Vector3* p = ((const Ogre::Vector3*)  tolua_tousertype(tolua_S,2,0));
  {
   WFMath::Point<2> tolua_ret = (WFMath::Point<2>)  EmberOgre::Convert::toWF<WFMath::Point<2> >(*p);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((WFMath::Point<2>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Point<2>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(WFMath::Point<2>));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Point<2>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toWF_Point2'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toWF<WFMath::Vector<3> > of class  EmberOgre::Convert */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Convert_toWF_Vector300
static int tolua_EmberOgre_EmberOgre_Convert_toWF_Vector300(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Convert",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Vector3",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ogre::Vector3* p = ((const Ogre::Vector3*)  tolua_tousertype(tolua_S,2,0));
  {
   WFMath::Vector<3> tolua_ret = (WFMath::Vector<3>)  EmberOgre::Convert::toWF<WFMath::Vector<3> >(*p);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((WFMath::Vector<3>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Vector<3>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(WFMath::Vector<3>));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Vector<3>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toWF_Vector3'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toWF of class  EmberOgre::Convert */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Convert_toWF00
static int tolua_EmberOgre_EmberOgre_Convert_toWF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Convert",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Vector2",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ogre::Vector2* p = ((const Ogre::Vector2*)  tolua_tousertype(tolua_S,2,0));
  {
   WFMath::Point<2> tolua_ret = (WFMath::Point<2>)  EmberOgre::Convert::toWF(*p);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((WFMath::Point<2>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Point<2>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(WFMath::Point<2>));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Point<2>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toWF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toOgre of class  EmberOgre::Convert */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Convert_toOgre01
static int tolua_EmberOgre_EmberOgre_Convert_toOgre01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Convert",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const WFMath::Point<3>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const WFMath::Point<3>* p = ((const WFMath::Point<3>*)  tolua_tousertype(tolua_S,2,0));
  {
   Ogre::Vector3 tolua_ret = (Ogre::Vector3)  EmberOgre::Convert::toOgre(*p);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::Vector3)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Vector3");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::Vector3));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Vector3");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Convert_toOgre00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: toOgre of class  EmberOgre::Convert */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Convert_toOgre02
static int tolua_EmberOgre_EmberOgre_Convert_toOgre02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Convert",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const WFMath::Vector<3>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const WFMath::Vector<3>* v = ((const WFMath::Vector<3>*)  tolua_tousertype(tolua_S,2,0));
  {
   Ogre::Vector3 tolua_ret = (Ogre::Vector3)  EmberOgre::Convert::toOgre(*v);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::Vector3)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Vector3");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::Vector3));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Vector3");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Convert_toOgre01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: toOgre of class  EmberOgre::Convert */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Convert_toOgre03
static int tolua_EmberOgre_EmberOgre_Convert_toOgre03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Convert",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const WFMath::Quaternion",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const WFMath::Quaternion* aq = ((const WFMath::Quaternion*)  tolua_tousertype(tolua_S,2,0));
  {
   Ogre::Quaternion tolua_ret = (Ogre::Quaternion)  EmberOgre::Convert::toOgre(*aq);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::Quaternion)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Quaternion");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::Quaternion));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Quaternion");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Convert_toOgre02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: toWF of class  EmberOgre::Convert */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Convert_toWF01
static int tolua_EmberOgre_EmberOgre_Convert_toWF01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Convert",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Quaternion",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Ogre::Quaternion* aq = ((const Ogre::Quaternion*)  tolua_tousertype(tolua_S,2,0));
  {
   WFMath::Quaternion tolua_ret = (WFMath::Quaternion)  EmberOgre::Convert::toWF(*aq);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((WFMath::Quaternion)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Quaternion");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(WFMath::Quaternion));
     tolua_pushusertype(tolua_S,tolua_obj,"WFMath::Quaternion");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Convert_toWF00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_new00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string prefix = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  int width = ((int)  tolua_tonumber(tolua_S,3,0));
  int height = ((int)  tolua_tonumber(tolua_S,4,0));
  {
   EmberOgre::SimpleRenderContext* tolua_ret = (EmberOgre::SimpleRenderContext*)  Mtolua_new((EmberOgre::SimpleRenderContext)(prefix,width,height));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::SimpleRenderContext");
   tolua_pushcppstring(tolua_S,(const char*)prefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_new00_local
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string prefix = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  int width = ((int)  tolua_tonumber(tolua_S,3,0));
  int height = ((int)  tolua_tonumber(tolua_S,4,0));
  {
   EmberOgre::SimpleRenderContext* tolua_ret = (EmberOgre::SimpleRenderContext*)  Mtolua_new((EmberOgre::SimpleRenderContext)(prefix,width,height));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::SimpleRenderContext");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)prefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_new01
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Ogre::TexturePtr",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string prefix = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  Ogre::TexturePtr texturePtr = *((Ogre::TexturePtr*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::SimpleRenderContext* tolua_ret = (EmberOgre::SimpleRenderContext*)  Mtolua_new((EmberOgre::SimpleRenderContext)(prefix,texturePtr));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::SimpleRenderContext");
   tolua_pushcppstring(tolua_S,(const char*)prefix);
  }
 }
 return 2;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_SimpleRenderContext_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_new01_local
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Ogre::TexturePtr",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string prefix = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  Ogre::TexturePtr texturePtr = *((Ogre::TexturePtr*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::SimpleRenderContext* tolua_ret = (EmberOgre::SimpleRenderContext*)  Mtolua_new((EmberOgre::SimpleRenderContext)(prefix,texturePtr));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::SimpleRenderContext");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)prefix);
  }
 }
 return 2;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_SimpleRenderContext_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSceneNode of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getSceneNode00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getSceneNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::SimpleRenderContext* self = (const EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSceneNode'", NULL);
#endif
  {
   Ogre::SceneNode* tolua_ret = (Ogre::SceneNode*)  self->getSceneNode();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ogre::SceneNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSceneNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCamera of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getCamera00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getCamera00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::SimpleRenderContext* self = (const EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCamera'", NULL);
#endif
  {
   Ogre::Camera* tolua_ret = (Ogre::Camera*)  self->getCamera();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ogre::Camera");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCamera'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultCameraDistance of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getDefaultCameraDistance00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getDefaultCameraDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::SimpleRenderContext* self = (const EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefaultCameraDistance'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getDefaultCameraDistance();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultCameraDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setActive of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_setActive00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_setActive00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
  bool active = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setActive'", NULL);
#endif
  {
   self->setActive(active);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setActive'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: showFull of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_showFull00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_showFull00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const Ogre::MovableObject",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::MovableObject* object = ((const Ogre::MovableObject*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'showFull'", NULL);
#endif
  {
   self->showFull(object);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'showFull'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: repositionCamera of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_repositionCamera00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_repositionCamera00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'repositionCamera'", NULL);
#endif
  {
   self->repositionCamera();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'repositionCamera'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: pitch of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_pitch00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_pitch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::Degree",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
  Ogre::Degree degrees = *((Ogre::Degree*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pitch'", NULL);
#endif
  {
   self->pitch(degrees);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'pitch'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: yaw of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_yaw00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_yaw00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::Degree",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
  Ogre::Degree degrees = *((Ogre::Degree*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'yaw'", NULL);
#endif
  {
   self->yaw(degrees);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'yaw'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: roll of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_roll00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_roll00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::Degree",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
  Ogre::Degree degrees = *((Ogre::Degree*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'roll'", NULL);
#endif
  {
   self->roll(degrees);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'roll'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCameraDistance of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_setCameraDistance00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_setCameraDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
  float distance = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCameraDistance'", NULL);
#endif
  {
   self->setCameraDistance(distance);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCameraDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCameraDistance of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getCameraDistance00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getCameraDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::SimpleRenderContext* self = (const EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCameraDistance'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getCameraDistance();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCameraDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAbsoluteCameraDistance of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getAbsoluteCameraDistance00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getAbsoluteCameraDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::SimpleRenderContext* self = (const EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAbsoluteCameraDistance'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getAbsoluteCameraDistance();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAbsoluteCameraDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEntityRotation of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getEntityRotation00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getEntityRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEntityRotation'", NULL);
#endif
  {
   Ogre::Quaternion tolua_ret = (Ogre::Quaternion)  self->getEntityRotation();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::Quaternion)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Quaternion");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::Quaternion));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Quaternion");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEntityRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resetCameraOrientation of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_resetCameraOrientation00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_resetCameraOrientation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resetCameraOrientation'", NULL);
#endif
  {
   self->resetCameraOrientation();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resetCameraOrientation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSceneManager of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getSceneManager00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getSceneManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::SimpleRenderContext* self = (const EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSceneManager'", NULL);
#endif
  {
   Ogre::SceneManager* tolua_ret = (Ogre::SceneManager*)  self->getSceneManager();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ogre::SceneManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSceneManager'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRenderTexture of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getRenderTexture00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getRenderTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRenderTexture'", NULL);
#endif
  {
   Ogre::RenderTexture* tolua_ret = (Ogre::RenderTexture*)  self->getRenderTexture();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ogre::RenderTexture");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRenderTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTexture of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getTexture00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTexture'", NULL);
#endif
  {
   Ogre::TexturePtr tolua_ret = (Ogre::TexturePtr)  self->getTexture();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::TexturePtr)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::TexturePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::TexturePtr));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::TexturePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCameraRootNode of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getCameraRootNode00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getCameraRootNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::SimpleRenderContext* self = (const EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCameraRootNode'", NULL);
#endif
  {
   Ogre::SceneNode* tolua_ret = (Ogre::SceneNode*)  self->getCameraRootNode();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ogre::SceneNode");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCameraRootNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getViewport of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getViewport00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getViewport00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::SimpleRenderContext* self = (const EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getViewport'", NULL);
#endif
  {
   Ogre::Viewport* tolua_ret = (Ogre::Viewport*)  self->getViewport();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ogre::Viewport");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getViewport'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLight of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getLight00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getLight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLight'", NULL);
#endif
  {
   Ogre::Light* tolua_ret = (Ogre::Light*)  self->getLight();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ogre::Light");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBackgroundColour of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_setBackgroundColour00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_setBackgroundColour00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::ColourValue",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::ColourValue* colour = ((const Ogre::ColourValue*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBackgroundColour'", NULL);
#endif
  {
   self->setBackgroundColour(*colour);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBackgroundColour'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBackgroundColour of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_setBackgroundColour01
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_setBackgroundColour01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
  float red = ((float)  tolua_tonumber(tolua_S,2,0));
  float green = ((float)  tolua_tonumber(tolua_S,3,0));
  float blue = ((float)  tolua_tonumber(tolua_S,4,0));
  float alpha = ((float)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBackgroundColour'", NULL);
#endif
  {
   self->setBackgroundColour(red,green,blue,alpha);
  }
 }
 return 0;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_SimpleRenderContext_setBackgroundColour00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTexture of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_setTexture00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_setTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::TexturePtr",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
  Ogre::TexturePtr texture = *((Ogre::TexturePtr*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTexture'", NULL);
#endif
  {
   self->setTexture(texture);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCameraPositionMode of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_getCameraPositionMode00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_getCameraPositionMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::SimpleRenderContext* self = (const EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCameraPositionMode'", NULL);
#endif
  {
   EmberOgre::SimpleRenderContext::CameraPositioningMode tolua_ret = (EmberOgre::SimpleRenderContext::CameraPositioningMode)  self->getCameraPositionMode();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCameraPositionMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCameraPositionMode of class  EmberOgre::SimpleRenderContext */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_SimpleRenderContext_setCameraPositionMode00
static int tolua_EmberOgre_EmberOgre_SimpleRenderContext_setCameraPositionMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::SimpleRenderContext",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::SimpleRenderContext* self = (EmberOgre::SimpleRenderContext*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::SimpleRenderContext::CameraPositioningMode mode = ((EmberOgre::SimpleRenderContext::CameraPositioningMode) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCameraPositionMode'", NULL);
#endif
  {
   self->setCameraPositionMode(mode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCameraPositionMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: showFull of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_showFull00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_showFull00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'showFull'", NULL);
#endif
  {
   self->showFull();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'showFull'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCameraDistance of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setCameraDistance00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setCameraDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
  float distance = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCameraDistance'", NULL);
#endif
  {
   self->setCameraDistance(distance);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCameraDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCameraDistance of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getCameraDistance00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getCameraDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCameraDistance'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getCameraDistance();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCameraDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAbsoluteCameraDistance of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getAbsoluteCameraDistance00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getAbsoluteCameraDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAbsoluteCameraDistance'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getAbsoluteCameraDistance();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAbsoluteCameraDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIsInputCatchingAllowed of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getIsInputCatchingAllowed00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getIsInputCatchingAllowed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::MovableObjectRenderer* self = (const EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIsInputCatchingAllowed'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getIsInputCatchingAllowed();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIsInputCatchingAllowed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setIsInputCatchingAllowed of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setIsInputCatchingAllowed00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setIsInputCatchingAllowed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
  bool allowed = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setIsInputCatchingAllowed'", NULL);
#endif
  {
   self->setIsInputCatchingAllowed(allowed);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setIsInputCatchingAllowed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoShowFull of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setAutoShowFull00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setAutoShowFull00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
  bool showFull = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoShowFull'", NULL);
#endif
  {
   self->setAutoShowFull(showFull);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoShowFull'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAutoShowFull of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getAutoShowFull00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getAutoShowFull00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::MovableObjectRenderer* self = (const EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAutoShowFull'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getAutoShowFull();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAutoShowFull'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getActive of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getActive00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getActive00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::MovableObjectRenderer* self = (const EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getActive'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getActive();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getActive'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setActive of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setActive00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setActive00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
  bool isActive = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setActive'", NULL);
#endif
  {
   self->setActive(isActive);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setActive'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEntityRotation of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getEntityRotation00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getEntityRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEntityRotation'", NULL);
#endif
  {
   Ogre::Quaternion tolua_ret = (Ogre::Quaternion)  self->getEntityRotation();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::Quaternion)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Quaternion");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::Quaternion));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::Quaternion");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEntityRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resetCameraOrientation of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_resetCameraOrientation00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_resetCameraOrientation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resetCameraOrientation'", NULL);
#endif
  {
   self->resetCameraOrientation();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resetCameraOrientation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: pitch of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_pitch00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_pitch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::Degree",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
  Ogre::Degree degrees = *((Ogre::Degree*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pitch'", NULL);
#endif
  {
   self->pitch(degrees);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'pitch'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: yaw of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_yaw00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_yaw00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::Degree",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
  Ogre::Degree degrees = *((Ogre::Degree*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'yaw'", NULL);
#endif
  {
   self->yaw(degrees);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'yaw'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: roll of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_roll00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_roll00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::Degree",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
  Ogre::Degree degrees = *((Ogre::Degree*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'roll'", NULL);
#endif
  {
   self->roll(degrees);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'roll'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: updateRender of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_updateRender00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_updateRender00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'updateRender'", NULL);
#endif
  {
   self->updateRender();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'updateRender'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBackgroundColour of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setBackgroundColour00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setBackgroundColour00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::ColourValue",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::ColourValue* colour = ((const Ogre::ColourValue*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBackgroundColour'", NULL);
#endif
  {
   self->setBackgroundColour(*colour);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBackgroundColour'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBackgroundColour of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setBackgroundColour01
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setBackgroundColour01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
  float red = ((float)  tolua_tonumber(tolua_S,2,0));
  float green = ((float)  tolua_tonumber(tolua_S,3,0));
  float blue = ((float)  tolua_tonumber(tolua_S,4,0));
  float alpha = ((float)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBackgroundColour'", NULL);
#endif
  {
   self->setBackgroundColour(red,green,blue,alpha);
  }
 }
 return 0;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setBackgroundColour00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: showAxis of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_showAxis00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_showAxis00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'showAxis'", NULL);
#endif
  {
   self->showAxis();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'showAxis'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hideAxis of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_hideAxis00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_hideAxis00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hideAxis'", NULL);
#endif
  {
   self->hideAxis();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hideAxis'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCameraPositionMode of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getCameraPositionMode00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getCameraPositionMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::MovableObjectRenderer* self = (const EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCameraPositionMode'", NULL);
#endif
  {
   EmberOgre::SimpleRenderContext::CameraPositioningMode tolua_ret = (EmberOgre::SimpleRenderContext::CameraPositioningMode)  self->getCameraPositionMode();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCameraPositionMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCameraPositionMode of class  EmberOgre::Gui::MovableObjectRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setCameraPositionMode00
static int tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setCameraPositionMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::MovableObjectRenderer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::MovableObjectRenderer* self = (EmberOgre::Gui::MovableObjectRenderer*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::SimpleRenderContext::CameraPositioningMode mode = ((EmberOgre::SimpleRenderContext::CameraPositioningMode) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCameraPositionMode'", NULL);
#endif
  {
   self->setCameraPositionMode(mode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCameraPositionMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::OgreEntityRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_new00
static int tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::OgreEntityRenderer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* image = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::OgreEntityRenderer* tolua_ret = (EmberOgre::Gui::OgreEntityRenderer*)  Mtolua_new((EmberOgre::Gui::OgreEntityRenderer)(image));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::OgreEntityRenderer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::OgreEntityRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::OgreEntityRenderer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* image = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::OgreEntityRenderer* tolua_ret = (EmberOgre::Gui::OgreEntityRenderer*)  Mtolua_new((EmberOgre::Gui::OgreEntityRenderer)(image));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::OgreEntityRenderer");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::OgreEntityRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_delete00
static int tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::OgreEntityRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::OgreEntityRenderer* self = (EmberOgre::Gui::OgreEntityRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: showEntity of class  EmberOgre::Gui::OgreEntityRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_showEntity00
static int tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_showEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::OgreEntityRenderer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::OgreEntityRenderer* self = (EmberOgre::Gui::OgreEntityRenderer*)  tolua_tousertype(tolua_S,1,0);
  const std::string mesh = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'showEntity'", NULL);
#endif
  {
   self->showEntity(mesh);
   tolua_pushcppstring(tolua_S,(const char*)mesh);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'showEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEntity of class  EmberOgre::Gui::OgreEntityRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_getEntity00
static int tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_getEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::OgreEntityRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::OgreEntityRenderer* self = (EmberOgre::Gui::OgreEntityRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEntity'", NULL);
#endif
  {
   Ogre::Entity* tolua_ret = (Ogre::Entity*)  self->getEntity();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ogre::Entity");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::ModelRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_new00
static int tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ModelRenderer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* image = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::ModelRenderer* tolua_ret = (EmberOgre::Gui::ModelRenderer*)  Mtolua_new((EmberOgre::Gui::ModelRenderer)(image));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ModelRenderer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::ModelRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ModelRenderer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* image = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::ModelRenderer* tolua_ret = (EmberOgre::Gui::ModelRenderer*)  Mtolua_new((EmberOgre::Gui::ModelRenderer)(image));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ModelRenderer");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::ModelRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_delete00
static int tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ModelRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ModelRenderer* self = (EmberOgre::Gui::ModelRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: showModel of class  EmberOgre::Gui::ModelRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_showModel00
static int tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_showModel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ModelRenderer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ModelRenderer* self = (EmberOgre::Gui::ModelRenderer*)  tolua_tousertype(tolua_S,1,0);
  const std::string modelName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'showModel'", NULL);
#endif
  {
   self->showModel(modelName);
   tolua_pushcppstring(tolua_S,(const char*)modelName);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'showModel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getModel of class  EmberOgre::Gui::ModelRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_getModel00
static int tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_getModel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ModelRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ModelRenderer* self = (EmberOgre::Gui::ModelRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getModel'", NULL);
#endif
  {
   EmberOgre::Model::Model* tolua_ret = (EmberOgre::Model::Model*)  self->getModel();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::Model");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getModel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: repositionSceneNode of class  EmberOgre::Gui::ModelRenderer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_repositionSceneNode00
static int tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_repositionSceneNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ModelRenderer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ModelRenderer* self = (EmberOgre::Gui::ModelRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'repositionSceneNode'", NULL);
#endif
  {
   self->repositionSceneNode();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'repositionSceneNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::ListHolder */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ListHolder_new00
static int tolua_EmberOgre_EmberOgre_Gui_ListHolder_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ListHolder",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Listbox",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Editbox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* listbox = ((CEGUI::Listbox*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Editbox* filterEditbox = ((CEGUI::Editbox*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::ListHolder* tolua_ret = (EmberOgre::Gui::ListHolder*)  Mtolua_new((EmberOgre::Gui::ListHolder)(listbox,filterEditbox));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ListHolder");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::ListHolder */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ListHolder_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_ListHolder_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::ListHolder",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Listbox",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Editbox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* listbox = ((CEGUI::Listbox*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Editbox* filterEditbox = ((CEGUI::Editbox*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::ListHolder* tolua_ret = (EmberOgre::Gui::ListHolder*)  Mtolua_new((EmberOgre::Gui::ListHolder)(listbox,filterEditbox));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::ListHolder");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::ListHolder */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ListHolder_delete00
static int tolua_EmberOgre_EmberOgre_Gui_ListHolder_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ListHolder",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ListHolder* self = (EmberOgre::Gui::ListHolder*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addItem of class  EmberOgre::Gui::ListHolder */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ListHolder_addItem00
static int tolua_EmberOgre_EmberOgre_Gui_ListHolder_addItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ListHolder",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ListHolder* self = (EmberOgre::Gui::ListHolder*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addItem'", NULL);
#endif
  {
   self->addItem(item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertItem of class  EmberOgre::Gui::ListHolder */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ListHolder_insertItem00
static int tolua_EmberOgre_EmberOgre_Gui_ListHolder_insertItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ListHolder",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const CEGUI::ListboxItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ListHolder* self = (EmberOgre::Gui::ListHolder*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::ListboxItem* position = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insertItem'", NULL);
#endif
  {
   self->insertItem(item,position);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insertItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeItem of class  EmberOgre::Gui::ListHolder */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ListHolder_removeItem00
static int tolua_EmberOgre_EmberOgre_Gui_ListHolder_removeItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ListHolder",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ListHolder* self = (EmberOgre::Gui::ListHolder*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeItem'", NULL);
#endif
  {
   self->removeItem(item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resetList of class  EmberOgre::Gui::ListHolder */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_ListHolder_resetList00
static int tolua_EmberOgre_EmberOgre_Gui_ListHolder_resetList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::ListHolder",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::ListHolder* self = (EmberOgre::Gui::ListHolder*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resetList'", NULL);
#endif
  {
   self->resetList();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resetList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: windowX of class  EmberOgre::MousePickerArgs */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__MousePickerArgs_windowX
static int tolua_get_EmberOgre__MousePickerArgs_windowX(lua_State* tolua_S)
{
  EmberOgre::MousePickerArgs* self = (EmberOgre::MousePickerArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'windowX'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->windowX);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: windowX of class  EmberOgre::MousePickerArgs */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__MousePickerArgs_windowX
static int tolua_set_EmberOgre__MousePickerArgs_windowX(lua_State* tolua_S)
{
  EmberOgre::MousePickerArgs* self = (EmberOgre::MousePickerArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'windowX'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->windowX = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: windowY of class  EmberOgre::MousePickerArgs */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__MousePickerArgs_windowY
static int tolua_get_EmberOgre__MousePickerArgs_windowY(lua_State* tolua_S)
{
  EmberOgre::MousePickerArgs* self = (EmberOgre::MousePickerArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'windowY'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->windowY);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: windowY of class  EmberOgre::MousePickerArgs */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__MousePickerArgs_windowY
static int tolua_set_EmberOgre__MousePickerArgs_windowY(lua_State* tolua_S)
{
  EmberOgre::MousePickerArgs* self = (EmberOgre::MousePickerArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'windowY'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->windowY = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: pickType of class  EmberOgre::MousePickerArgs */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__MousePickerArgs_pickType
static int tolua_get_EmberOgre__MousePickerArgs_pickType(lua_State* tolua_S)
{
  EmberOgre::MousePickerArgs* self = (EmberOgre::MousePickerArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pickType'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->pickType);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: pickType of class  EmberOgre::MousePickerArgs */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__MousePickerArgs_pickType
static int tolua_set_EmberOgre__MousePickerArgs_pickType(lua_State* tolua_S)
{
  EmberOgre::MousePickerArgs* self = (EmberOgre::MousePickerArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pickType'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->pickType = ((EmberOgre::MousePickType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: entity of class  EmberOgre::EntityPickResult */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EntityPickResult_entity_ptr
static int tolua_get_EmberOgre__EntityPickResult_entity_ptr(lua_State* tolua_S)
{
  EmberOgre::EntityPickResult* self = (EmberOgre::EntityPickResult*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'entity'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)self->entity,"EmberOgre::EmberEntity");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: entity of class  EmberOgre::EntityPickResult */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EntityPickResult_entity_ptr
static int tolua_set_EmberOgre__EntityPickResult_entity_ptr(lua_State* tolua_S)
{
  EmberOgre::EntityPickResult* self = (EmberOgre::EntityPickResult*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'entity'",NULL);
  if (!tolua_isusertype(tolua_S,2,"EmberOgre::EmberEntity",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: position of class  EmberOgre::EntityPickResult */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EntityPickResult_position
static int tolua_get_EmberOgre__EntityPickResult_position(lua_State* tolua_S)
{
  EmberOgre::EntityPickResult* self = (EmberOgre::EntityPickResult*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'position'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->position,"Ogre::Vector3");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: position of class  EmberOgre::EntityPickResult */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EntityPickResult_position
static int tolua_set_EmberOgre__EntityPickResult_position(lua_State* tolua_S)
{
  EmberOgre::EntityPickResult* self = (EmberOgre::EntityPickResult*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'position'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::Vector3",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->position = *((Ogre::Vector3*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: distance of class  EmberOgre::EntityPickResult */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EntityPickResult_distance
static int tolua_get_EmberOgre__EntityPickResult_distance(lua_State* tolua_S)
{
  EmberOgre::EntityPickResult* self = (EmberOgre::EntityPickResult*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'distance'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->distance);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: distance of class  EmberOgre::EntityPickResult */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EntityPickResult_distance
static int tolua_set_EmberOgre__EntityPickResult_distance(lua_State* tolua_S)
{
  EmberOgre::EntityPickResult* self = (EmberOgre::EntityPickResult*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'distance'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->distance = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventPickedEntity of class  EmberOgre::EntityWorldPickListener */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EntityWorldPickListener_EventPickedEntity
static int tolua_get_EmberOgre__EntityWorldPickListener_EventPickedEntity(lua_State* tolua_S)
{
  EmberOgre::EntityWorldPickListener* self = (EmberOgre::EntityWorldPickListener*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventPickedEntity'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventPickedEntity,"sigc::signal<void,const std::vector<EmberOgre::EntityPickResult>&,const EmberOgre::MousePickerArgs&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  EmberOgre::Model::ModelDefinitionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_getSingleton00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Model::ModelDefinitionManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Model::ModelDefinitionManager& tolua_ret = (EmberOgre::Model::ModelDefinitionManager&)  EmberOgre::Model::ModelDefinitionManager::getSingleton();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Model::ModelDefinitionManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: exportScript of class  EmberOgre::Model::ModelDefinitionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_exportScript00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_exportScript00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinitionManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Model::ModelDefnPtr",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinitionManager* self = (EmberOgre::Model::ModelDefinitionManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::ModelDefnPtr definition = *((EmberOgre::Model::ModelDefnPtr*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'exportScript'", NULL);
#endif
  {
   self->exportScript(definition);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'exportScript'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  EmberOgre::Model::ModelDefinitionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_create00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinitionManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinitionManager* self = (EmberOgre::Model::ModelDefinitionManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string group = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create'", NULL);
#endif
  {
   EmberOgre::Model::ModelDefnPtr tolua_ret = (EmberOgre::Model::ModelDefnPtr)  self->create(name,group);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((EmberOgre::Model::ModelDefnPtr)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Model::ModelDefnPtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(EmberOgre::Model::ModelDefnPtr));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Model::ModelDefnPtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushcppstring(tolua_S,(const char*)name);
   tolua_pushcppstring(tolua_S,(const char*)group);
  }
 }
 return 3;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getByName of class  EmberOgre::Model::ModelDefinitionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_getByName00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_getByName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinitionManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinitionManager* self = (EmberOgre::Model::ModelDefinitionManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getByName'", NULL);
#endif
  {
   EmberOgre::Model::ModelDefnPtr tolua_ret = (EmberOgre::Model::ModelDefnPtr)  self->getByName(name);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((EmberOgre::Model::ModelDefnPtr)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Model::ModelDefnPtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(EmberOgre::Model::ModelDefnPtr));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Model::ModelDefnPtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getByName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAllMeshes of class  EmberOgre::Model::ModelDefinitionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_getAllMeshes00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_getAllMeshes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::ModelDefinitionManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::ModelDefinitionManager* self = (const EmberOgre::Model::ModelDefinitionManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAllMeshes'", NULL);
#endif
  {
   const std::vector<std::string> tolua_ret = (const std::vector<std::string>)  self->getAllMeshes();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<std::string>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"const std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const std::vector<std::string>));
     tolua_pushusertype(tolua_S,tolua_obj,"const std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAllMeshes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getShowModels of class  EmberOgre::Model::ModelDefinitionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_getShowModels00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_getShowModels00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Model::ModelDefinitionManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Model::ModelDefinitionManager* self = (const EmberOgre::Model::ModelDefinitionManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getShowModels'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getShowModels();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getShowModels'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setShowModels of class  EmberOgre::Model::ModelDefinitionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_setShowModels00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_setShowModels00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinitionManager",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinitionManager* self = (EmberOgre::Model::ModelDefinitionManager*)  tolua_tousertype(tolua_S,1,0);
  bool show = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowModels'", NULL);
#endif
  {
   self->setShowModels(show);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowModels'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Model::ModelDefinitionAtlasComposer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_new00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Model::ModelDefinitionAtlasComposer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Model::ModelDefinitionAtlasComposer* tolua_ret = (EmberOgre::Model::ModelDefinitionAtlasComposer*)  Mtolua_new((EmberOgre::Model::ModelDefinitionAtlasComposer)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::ModelDefinitionAtlasComposer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Model::ModelDefinitionAtlasComposer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_new00_local
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Model::ModelDefinitionAtlasComposer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Model::ModelDefinitionAtlasComposer* tolua_ret = (EmberOgre::Model::ModelDefinitionAtlasComposer*)  Mtolua_new((EmberOgre::Model::ModelDefinitionAtlasComposer)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::ModelDefinitionAtlasComposer");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Model::ModelDefinitionAtlasComposer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_delete00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinitionAtlasComposer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinitionAtlasComposer* self = (EmberOgre::Model::ModelDefinitionAtlasComposer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: compose of class  EmberOgre::Model::ModelDefinitionAtlasComposer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_compose00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_compose00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinitionAtlasComposer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinitionAtlasComposer* self = (EmberOgre::Model::ModelDefinitionAtlasComposer*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::Model* model = ((EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,2,0));
  const std::string typeName = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string parentTypeName = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  float scale = ((float)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'compose'", NULL);
#endif
  {
   Atlas::Message::MapType tolua_ret = (Atlas::Message::MapType)  self->compose(model,typeName,parentTypeName,scale);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Atlas::Message::MapType)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::MapType");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Message::MapType));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::MapType");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushcppstring(tolua_S,(const char*)typeName);
   tolua_pushcppstring(tolua_S,(const char*)parentTypeName);
  }
 }
 return 3;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'compose'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: composeToStream of class  EmberOgre::Model::ModelDefinitionAtlasComposer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_composeToStream00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_composeToStream00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinitionAtlasComposer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::iostream",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinitionAtlasComposer* self = (EmberOgre::Model::ModelDefinitionAtlasComposer*)  tolua_tousertype(tolua_S,1,0);
  std::iostream* outstream = ((std::iostream*)  tolua_tousertype(tolua_S,2,0));
  EmberOgre::Model::Model* model = ((EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,3,0));
  const std::string typeName = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  const std::string parentTypeName = ((const std::string)  tolua_tocppstring(tolua_S,5,0));
  float scale = ((float)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'composeToStream'", NULL);
#endif
  {
   self->composeToStream(*outstream,model,typeName,parentTypeName,scale);
   tolua_pushcppstring(tolua_S,(const char*)typeName);
   tolua_pushcppstring(tolua_S,(const char*)parentTypeName);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'composeToStream'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: composeToFile of class  EmberOgre::Model::ModelDefinitionAtlasComposer */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_composeToFile00
static int tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_composeToFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Model::ModelDefinitionAtlasComposer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Model::Model",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Model::ModelDefinitionAtlasComposer* self = (EmberOgre::Model::ModelDefinitionAtlasComposer*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::Model* model = ((EmberOgre::Model::Model*)  tolua_tousertype(tolua_S,2,0));
  const std::string typeName = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string parentTypeName = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  float scale = ((float)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'composeToFile'", NULL);
#endif
  {
   self->composeToFile(model,typeName,parentTypeName,scale);
   tolua_pushcppstring(tolua_S,(const char*)typeName);
   tolua_pushcppstring(tolua_S,(const char*)parentTypeName);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'composeToFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startMove of class  EmberOgre::Authoring::EntityMoveManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityMoveManager_startMove00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityMoveManager_startMove00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityMoveManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::EmberEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityMoveManager* self = (EmberOgre::Authoring::EntityMoveManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startMove'", NULL);
#endif
  {
   self->startMove(*entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startMove'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: runCommand of class  EmberOgre::Authoring::EntityMoveManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityMoveManager_runCommand00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityMoveManager_runCommand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityMoveManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityMoveManager* self = (EmberOgre::Authoring::EntityMoveManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string command = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string args = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'runCommand'", NULL);
#endif
  {
   self->runCommand(command,args);
   tolua_pushcppstring(tolua_S,(const char*)command);
   tolua_pushcppstring(tolua_S,(const char*)args);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'runCommand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventStartMoving of class  EmberOgre::Authoring::EntityMoveManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Authoring__EntityMoveManager_EventStartMoving
static int tolua_get_EmberOgre__Authoring__EntityMoveManager_EventStartMoving(lua_State* tolua_S)
{
  EmberOgre::Authoring::EntityMoveManager* self = (EmberOgre::Authoring::EntityMoveManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventStartMoving'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventStartMoving,"sigc::signal<void,EmberOgre::EmberEntity&,EmberOgre::Authoring::EntityMover&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventStartMoving of class  EmberOgre::Authoring::EntityMoveManager */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Authoring__EntityMoveManager_EventStartMoving
static int tolua_set_EmberOgre__Authoring__EntityMoveManager_EventStartMoving(lua_State* tolua_S)
{
  EmberOgre::Authoring::EntityMoveManager* self = (EmberOgre::Authoring::EntityMoveManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventStartMoving'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::EmberEntity&,EmberOgre::Authoring::EntityMover&>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventStartMoving = *((sigc::signal<void,EmberOgre::EmberEntity&,EmberOgre::Authoring::EntityMover&>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventFinishedMoving of class  EmberOgre::Authoring::EntityMoveManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Authoring__EntityMoveManager_EventFinishedMoving
static int tolua_get_EmberOgre__Authoring__EntityMoveManager_EventFinishedMoving(lua_State* tolua_S)
{
  EmberOgre::Authoring::EntityMoveManager* self = (EmberOgre::Authoring::EntityMoveManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventFinishedMoving'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventFinishedMoving,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventFinishedMoving of class  EmberOgre::Authoring::EntityMoveManager */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Authoring__EntityMoveManager_EventFinishedMoving
static int tolua_set_EmberOgre__Authoring__EntityMoveManager_EventFinishedMoving(lua_State* tolua_S)
{
  EmberOgre::Authoring::EntityMoveManager* self = (EmberOgre::Authoring::EntityMoveManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventFinishedMoving'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventFinishedMoving = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventCancelledMoving of class  EmberOgre::Authoring::EntityMoveManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Authoring__EntityMoveManager_EventCancelledMoving
static int tolua_get_EmberOgre__Authoring__EntityMoveManager_EventCancelledMoving(lua_State* tolua_S)
{
  EmberOgre::Authoring::EntityMoveManager* self = (EmberOgre::Authoring::EntityMoveManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventCancelledMoving'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventCancelledMoving,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventCancelledMoving of class  EmberOgre::Authoring::EntityMoveManager */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Authoring__EntityMoveManager_EventCancelledMoving
static int tolua_set_EmberOgre__Authoring__EntityMoveManager_EventCancelledMoving(lua_State* tolua_S)
{
  EmberOgre::Authoring::EntityMoveManager* self = (EmberOgre::Authoring::EntityMoveManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventCancelledMoving'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventCancelledMoving = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Authoring::GUIAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_new00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Authoring::GUIAdapter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string type = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   EmberOgre::Authoring::GUIAdapter* tolua_ret = (EmberOgre::Authoring::GUIAdapter*)  Mtolua_new((EmberOgre::Authoring::GUIAdapter)(type));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Authoring::GUIAdapter");
   tolua_pushcppstring(tolua_S,(const char*)type);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Authoring::GUIAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_new00_local
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Authoring::GUIAdapter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string type = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   EmberOgre::Authoring::GUIAdapter* tolua_ret = (EmberOgre::Authoring::GUIAdapter*)  Mtolua_new((EmberOgre::Authoring::GUIAdapter)(type));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Authoring::GUIAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)type);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Authoring::GUIAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_delete00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::GUIAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::GUIAdapter* self = (EmberOgre::Authoring::GUIAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getType of class  EmberOgre::Authoring::GUIAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_getType00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_getType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Authoring::GUIAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Authoring::GUIAdapter* self = (const EmberOgre::Authoring::GUIAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getType'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getType();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: attach of class  EmberOgre::Authoring::GUIAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_attach00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_attach00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::GUIAdapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::GUIAdapter* self = (EmberOgre::Authoring::GUIAdapter*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'attach'", NULL);
#endif
  {
   self->attach(window);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'attach'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: detach of class  EmberOgre::Authoring::GUIAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_detach00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_detach00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::GUIAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::GUIAdapter* self = (EmberOgre::Authoring::GUIAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'detach'", NULL);
#endif
  {
   self->detach();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'detach'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getValue of class  EmberOgre::Authoring::GUIAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_getValue00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_getValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::GUIAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::GUIAdapter* self = (EmberOgre::Authoring::GUIAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValue'", NULL);
#endif
  {
   Atlas::Message::Element tolua_ret = (Atlas::Message::Element)  self->getValue();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Atlas::Message::Element)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Message::Element));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Message::Element");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTitle of class  EmberOgre::Authoring::GUIAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_setTitle00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_setTitle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::GUIAdapter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::GUIAdapter* self = (EmberOgre::Authoring::GUIAdapter*)  tolua_tousertype(tolua_S,1,0);
  const std::string title = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTitle'", NULL);
#endif
  {
   self->setTitle(title);
   tolua_pushcppstring(tolua_S,(const char*)title);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTitle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTitle of class  EmberOgre::Authoring::GUIAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_getTitle00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_getTitle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Authoring::GUIAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Authoring::GUIAdapter* self = (const EmberOgre::Authoring::GUIAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTitle'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getTitle();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTitle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTooltip of class  EmberOgre::Authoring::GUIAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_setTooltip00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_setTooltip00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::GUIAdapter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::GUIAdapter* self = (EmberOgre::Authoring::GUIAdapter*)  tolua_tousertype(tolua_S,1,0);
  const std::string tooltip = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTooltip'", NULL);
#endif
  {
   self->setTooltip(tooltip);
   tolua_pushcppstring(tolua_S,(const char*)tooltip);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTooltip'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTooltip of class  EmberOgre::Authoring::GUIAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_getTooltip00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_getTooltip00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Authoring::GUIAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Authoring::GUIAdapter* self = (const EmberOgre::Authoring::GUIAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTooltip'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getTooltip();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTooltip'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addSuggestion of class  EmberOgre::Authoring::GUIAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_addSuggestion00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_addSuggestion00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::GUIAdapter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::GUIAdapter* self = (EmberOgre::Authoring::GUIAdapter*)  tolua_tousertype(tolua_S,1,0);
  const std::string value = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string text = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addSuggestion'", NULL);
#endif
  {
   self->addSuggestion(value,text);
   tolua_pushcppstring(tolua_S,(const char*)value);
   tolua_pushcppstring(tolua_S,(const char*)text);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addSuggestion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Authoring::EntityRecipe */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_new00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Authoring::EntityRecipe",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Ogre::ResourceManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const Ogre::String",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"Ogre::ResourceHandle",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const Ogre::String",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,6,1,&tolua_err) ||
     !tolua_isusertype(tolua_S,7,"Ogre::ManualResourceLoader",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ogre::ResourceManager* creator = ((Ogre::ResourceManager*)  tolua_tousertype(tolua_S,2,0));
  const Ogre::String* name = ((const Ogre::String*)  tolua_tousertype(tolua_S,3,0));
  Ogre::ResourceHandle handle = *((Ogre::ResourceHandle*)  tolua_tousertype(tolua_S,4,0));
  const Ogre::String* group = ((const Ogre::String*)  tolua_tousertype(tolua_S,5,0));
  bool isManual = ((bool)  tolua_toboolean(tolua_S,6,false));
  Ogre::ManualResourceLoader* loader = ((Ogre::ManualResourceLoader*)  tolua_tousertype(tolua_S,7,0));
  {
   EmberOgre::Authoring::EntityRecipe* tolua_ret = (EmberOgre::Authoring::EntityRecipe*)  Mtolua_new((EmberOgre::Authoring::EntityRecipe)(creator,*name,handle,*group,isManual,loader));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Authoring::EntityRecipe");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Authoring::EntityRecipe */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_new00_local
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Authoring::EntityRecipe",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Ogre::ResourceManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const Ogre::String",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"Ogre::ResourceHandle",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const Ogre::String",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,6,1,&tolua_err) ||
     !tolua_isusertype(tolua_S,7,"Ogre::ManualResourceLoader",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ogre::ResourceManager* creator = ((Ogre::ResourceManager*)  tolua_tousertype(tolua_S,2,0));
  const Ogre::String* name = ((const Ogre::String*)  tolua_tousertype(tolua_S,3,0));
  Ogre::ResourceHandle handle = *((Ogre::ResourceHandle*)  tolua_tousertype(tolua_S,4,0));
  const Ogre::String* group = ((const Ogre::String*)  tolua_tousertype(tolua_S,5,0));
  bool isManual = ((bool)  tolua_toboolean(tolua_S,6,false));
  Ogre::ManualResourceLoader* loader = ((Ogre::ManualResourceLoader*)  tolua_tousertype(tolua_S,7,0));
  {
   EmberOgre::Authoring::EntityRecipe* tolua_ret = (EmberOgre::Authoring::EntityRecipe*)  Mtolua_new((EmberOgre::Authoring::EntityRecipe)(creator,*name,handle,*group,isManual,loader));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Authoring::EntityRecipe");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Authoring::EntityRecipe */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_delete00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityRecipe",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityRecipe* self = (EmberOgre::Authoring::EntityRecipe*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: loadImpl of class  EmberOgre::Authoring::EntityRecipe */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_loadImpl00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_loadImpl00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityRecipe",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityRecipe* self = (EmberOgre::Authoring::EntityRecipe*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadImpl'", NULL);
#endif
  {
   self->loadImpl();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadImpl'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: unloadImpl of class  EmberOgre::Authoring::EntityRecipe */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_unloadImpl00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_unloadImpl00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityRecipe",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityRecipe* self = (EmberOgre::Authoring::EntityRecipe*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unloadImpl'", NULL);
#endif
  {
   self->unloadImpl();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'unloadImpl'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: calculateSize of class  EmberOgre::Authoring::EntityRecipe */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_calculateSize00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_calculateSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Authoring::EntityRecipe",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Authoring::EntityRecipe* self = (const EmberOgre::Authoring::EntityRecipe*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'calculateSize'", NULL);
#endif
  {
   size_t tolua_ret = (size_t)  self->calculateSize();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((size_t)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"size_t");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(size_t));
     tolua_pushusertype(tolua_S,tolua_obj,"size_t");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'calculateSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getGUIAdapters of class  EmberOgre::Authoring::EntityRecipe */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_getGUIAdapters00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_getGUIAdapters00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityRecipe",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityRecipe* self = (EmberOgre::Authoring::EntityRecipe*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getGUIAdapters'", NULL);
#endif
  {
   const EmberOgre::Authoring::GUIAdaptersStore& tolua_ret = (const EmberOgre::Authoring::GUIAdaptersStore&)  self->getGUIAdapters();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const EmberOgre::Authoring::GUIAdaptersStore");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getGUIAdapters'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAuthor of class  EmberOgre::Authoring::EntityRecipe */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_setAuthor00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_setAuthor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityRecipe",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityRecipe* self = (EmberOgre::Authoring::EntityRecipe*)  tolua_tousertype(tolua_S,1,0);
  const std::string author = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAuthor'", NULL);
#endif
  {
   self->setAuthor(author);
   tolua_pushcppstring(tolua_S,(const char*)author);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAuthor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAuthor of class  EmberOgre::Authoring::EntityRecipe */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_getAuthor00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_getAuthor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Authoring::EntityRecipe",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Authoring::EntityRecipe* self = (const EmberOgre::Authoring::EntityRecipe*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAuthor'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getAuthor();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAuthor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDescription of class  EmberOgre::Authoring::EntityRecipe */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_setDescription00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_setDescription00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityRecipe",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityRecipe* self = (EmberOgre::Authoring::EntityRecipe*)  tolua_tousertype(tolua_S,1,0);
  const std::string description = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDescription'", NULL);
#endif
  {
   self->setDescription(description);
   tolua_pushcppstring(tolua_S,(const char*)description);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDescription'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDescription of class  EmberOgre::Authoring::EntityRecipe */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_getDescription00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_getDescription00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Authoring::EntityRecipe",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Authoring::EntityRecipe* self = (const EmberOgre::Authoring::EntityRecipe*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDescription'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getDescription();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDescription'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createEntity of class  EmberOgre::Authoring::EntityRecipe */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_createEntity00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_createEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityRecipe",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Eris::TypeService",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityRecipe* self = (EmberOgre::Authoring::EntityRecipe*)  tolua_tousertype(tolua_S,1,0);
  Eris::TypeService* typeService = ((Eris::TypeService*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createEntity'", NULL);
#endif
  {
   self->createEntity(*typeService);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Authoring::EntityRecipePtr */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipePtr_delete00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipePtr_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityRecipePtr",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityRecipePtr* self = (EmberOgre::Authoring::EntityRecipePtr*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  EmberOgre::Authoring::EntityRecipePtr */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipePtr_get00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipePtr_get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityRecipePtr",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityRecipePtr* self = (EmberOgre::Authoring::EntityRecipePtr*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'", NULL);
#endif
  {
   EmberOgre::Authoring::EntityRecipe* tolua_ret = (EmberOgre::Authoring::EntityRecipe*)  self->get();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Authoring::EntityRecipe");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: first of class  value_type */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Authoring__GUIAdaptersStore__value_type_first
static int tolua_get_EmberOgre__Authoring__GUIAdaptersStore__value_type_first(lua_State* tolua_S)
{
  EmberOgre::Authoring::GUIAdaptersStore::value_type* self = (EmberOgre::Authoring::GUIAdaptersStore::value_type*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'first'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->first);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: second of class  value_type */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Authoring__GUIAdaptersStore__value_type_second_ptr
static int tolua_get_EmberOgre__Authoring__GUIAdaptersStore__value_type_second_ptr(lua_State* tolua_S)
{
  EmberOgre::Authoring::GUIAdaptersStore::value_type* self = (EmberOgre::Authoring::GUIAdaptersStore::value_type*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'second'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)self->second,"EmberOgre::Authoring::GUIAdapter");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: second of class  value_type */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Authoring__GUIAdaptersStore__value_type_second_ptr
static int tolua_set_EmberOgre__Authoring__GUIAdaptersStore__value_type_second_ptr(lua_State* tolua_S)
{
  EmberOgre::Authoring::GUIAdaptersStore::value_type* self = (EmberOgre::Authoring::GUIAdaptersStore::value_type*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'second'",NULL);
  if (!tolua_isusertype(tolua_S,2,"EmberOgre::Authoring::GUIAdapter",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->second = ((EmberOgre::Authoring::GUIAdapter*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_ptr of class  const_iterator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_const_iterator_get00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_const_iterator_get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::GUIAdaptersStore::const_iterator",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::GUIAdaptersStore::const_iterator* self = (EmberOgre::Authoring::GUIAdaptersStore::const_iterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_ptr'", NULL);
#endif
  {
   EmberOgre::Authoring::GUIAdaptersStore::value_type& tolua_ret = (EmberOgre::Authoring::GUIAdaptersStore::value_type&)  self->__operator_ptr();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Authoring::GUIAdaptersStore::value_type");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_pp of class  const_iterator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_const_iterator_next00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_const_iterator_next00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::GUIAdaptersStore::const_iterator",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::GUIAdaptersStore::const_iterator* self = (EmberOgre::Authoring::GUIAdaptersStore::const_iterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_pp'", NULL);
#endif
  {
   EmberOgre::Authoring::GUIAdaptersStore::const_iterator& tolua_ret = (EmberOgre::Authoring::GUIAdaptersStore::const_iterator&)  self->__operator_pp();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Authoring::GUIAdaptersStore::const_iterator");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  const_iterator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_const_iterator__eq00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_const_iterator__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::GUIAdaptersStore::const_iterator",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const EmberOgre::Authoring::GUIAdaptersStore::const_iterator",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::GUIAdaptersStore::const_iterator* self = (EmberOgre::Authoring::GUIAdaptersStore::const_iterator*)  tolua_tousertype(tolua_S,1,0);
  const EmberOgre::Authoring::GUIAdaptersStore::const_iterator* value = ((const EmberOgre::Authoring::GUIAdaptersStore::const_iterator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->operator==(*value);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: begin of class  EmberOgre::Authoring::GUIAdaptersStore */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_begin00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_begin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Authoring::GUIAdaptersStore",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Authoring::GUIAdaptersStore* self = (const EmberOgre::Authoring::GUIAdaptersStore*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'begin'", NULL);
#endif
  {
   EmberOgre::Authoring::GUIAdaptersStore::const_iterator tolua_ret = (EmberOgre::Authoring::GUIAdaptersStore::const_iterator)  self->begin();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((EmberOgre::Authoring::GUIAdaptersStore::const_iterator)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Authoring::GUIAdaptersStore::const_iterator");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(EmberOgre::Authoring::GUIAdaptersStore::const_iterator));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Authoring::GUIAdaptersStore::const_iterator");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'begin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: end of class  EmberOgre::Authoring::GUIAdaptersStore */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_theEnd00
static int tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_theEnd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Authoring::GUIAdaptersStore",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Authoring::GUIAdaptersStore* self = (const EmberOgre::Authoring::GUIAdaptersStore*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'end'", NULL);
#endif
  {
   EmberOgre::Authoring::GUIAdaptersStore::const_iterator tolua_ret = (EmberOgre::Authoring::GUIAdaptersStore::const_iterator)  self->end();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((EmberOgre::Authoring::GUIAdaptersStore::const_iterator)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Authoring::GUIAdaptersStore::const_iterator");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(EmberOgre::Authoring::GUIAdaptersStore::const_iterator));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Authoring::GUIAdaptersStore::const_iterator");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'theEnd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  EmberOgre::Authoring::EntityRecipeManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_getSingleton00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Authoring::EntityRecipeManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Authoring::EntityRecipeManager& tolua_ret = (EmberOgre::Authoring::EntityRecipeManager&)  EmberOgre::Authoring::EntityRecipeManager::getSingleton();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Authoring::EntityRecipeManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Authoring::EntityRecipeManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_new00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Authoring::EntityRecipeManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Authoring::EntityRecipeManager* tolua_ret = (EmberOgre::Authoring::EntityRecipeManager*)  Mtolua_new((EmberOgre::Authoring::EntityRecipeManager)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Authoring::EntityRecipeManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Authoring::EntityRecipeManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_new00_local
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Authoring::EntityRecipeManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Authoring::EntityRecipeManager* tolua_ret = (EmberOgre::Authoring::EntityRecipeManager*)  Mtolua_new((EmberOgre::Authoring::EntityRecipeManager)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Authoring::EntityRecipeManager");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Authoring::EntityRecipeManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_delete00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityRecipeManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityRecipeManager* self = (EmberOgre::Authoring::EntityRecipeManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  EmberOgre::Authoring::EntityRecipeManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_create00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityRecipeManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::String",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const Ogre::String",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"Ogre::ManualResourceLoader",1,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"const Ogre::NameValuePairList",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityRecipeManager* self = (EmberOgre::Authoring::EntityRecipeManager*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::String* name = ((const Ogre::String*)  tolua_tousertype(tolua_S,2,0));
  const Ogre::String* group = ((const Ogre::String*)  tolua_tousertype(tolua_S,3,0));
  bool isManual = ((bool)  tolua_toboolean(tolua_S,4,false));
  Ogre::ManualResourceLoader* loader = ((Ogre::ManualResourceLoader*)  tolua_tousertype(tolua_S,5,0));
  const Ogre::NameValuePairList* createParams = ((const Ogre::NameValuePairList*)  tolua_tousertype(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create'", NULL);
#endif
  {
   Ogre::ResourcePtr tolua_ret = (Ogre::ResourcePtr)  self->create(*name,*group,isManual,loader,createParams);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::ResourcePtr)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::ResourcePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::ResourcePtr));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::ResourcePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: parseScript of class  EmberOgre::Authoring::EntityRecipeManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_parseScript00
static int tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_parseScript00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::EntityRecipeManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::DataStreamPtr",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const Ogre::String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::EntityRecipeManager* self = (EmberOgre::Authoring::EntityRecipeManager*)  tolua_tousertype(tolua_S,1,0);
  Ogre::DataStreamPtr* stream = ((Ogre::DataStreamPtr*)  tolua_tousertype(tolua_S,2,0));
  const Ogre::String* groupName = ((const Ogre::String*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'parseScript'", NULL);
#endif
  {
   self->parseScript(*stream,*groupName);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'parseScript'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: __Ember of class  EmberOgre::Authoring::EntityRecipeManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Authoring__EntityRecipeManager___Ember__Singleton_EntityRecipeManager___
static int tolua_get_EmberOgre__Authoring__EntityRecipeManager___Ember__Singleton_EntityRecipeManager___(lua_State* tolua_S)
{
  EmberOgre::Authoring::EntityRecipeManager* self = (EmberOgre::Authoring::EntityRecipeManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable '__Ember'",NULL);
#endif
#ifdef __cplusplus
   tolua_pushusertype(tolua_S,(void*)static_cast<Ember::Singleton<EmberOgre::Authoring::EntityRecipeManager>*>(self), "Ember::Singleton<EmberOgre::Authoring::EntityRecipeManager>");
#else
   tolua_pushusertype(tolua_S,(void*)((Ember::Singleton<EmberOgre::Authoring::EntityRecipeManager>*)self), "Ember::Singleton<EmberOgre::Authoring::EntityRecipeManager>");
#endif
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::EntityCreator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityCreator_new00
static int tolua_EmberOgre_EmberOgre_Gui_EntityCreator_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::EntityCreator",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::World",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::World* world = ((EmberOgre::World*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::EntityCreator* tolua_ret = (EmberOgre::Gui::EntityCreator*)  Mtolua_new((EmberOgre::Gui::EntityCreator)(*world));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityCreator");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::EntityCreator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityCreator_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_EntityCreator_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::EntityCreator",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::World",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::World* world = ((EmberOgre::World*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Gui::EntityCreator* tolua_ret = (EmberOgre::Gui::EntityCreator*)  Mtolua_new((EmberOgre::Gui::EntityCreator)(*world));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::EntityCreator");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::EntityCreator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityCreator_delete00
static int tolua_EmberOgre_EmberOgre_Gui_EntityCreator_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityCreator",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityCreator* self = (EmberOgre::Gui::EntityCreator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRecipe of class  EmberOgre::Gui::EntityCreator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityCreator_setRecipe00
static int tolua_EmberOgre_EmberOgre_Gui_EntityCreator_setRecipe00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityCreator",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::Authoring::EntityRecipe",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityCreator* self = (EmberOgre::Gui::EntityCreator*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Authoring::EntityRecipe* recipe = ((EmberOgre::Authoring::EntityRecipe*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRecipe'", NULL);
#endif
  {
   self->setRecipe(*recipe);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRecipe'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toggleCreateMode of class  EmberOgre::Gui::EntityCreator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityCreator_toggleCreateMode00
static int tolua_EmberOgre_EmberOgre_Gui_EntityCreator_toggleCreateMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityCreator",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityCreator* self = (EmberOgre::Gui::EntityCreator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toggleCreateMode'", NULL);
#endif
  {
   self->toggleCreateMode();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toggleCreateMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRandomizeOrientation of class  EmberOgre::Gui::EntityCreator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityCreator_setRandomizeOrientation00
static int tolua_EmberOgre_EmberOgre_Gui_EntityCreator_setRandomizeOrientation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityCreator",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityCreator* self = (EmberOgre::Gui::EntityCreator*)  tolua_tousertype(tolua_S,1,0);
  bool randomize = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRandomizeOrientation'", NULL);
#endif
  {
   self->setRandomizeOrientation(randomize);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRandomizeOrientation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createEntity of class  EmberOgre::Gui::EntityCreator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityCreator_createEntity00
static int tolua_EmberOgre_EmberOgre_Gui_EntityCreator_createEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityCreator",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityCreator* self = (EmberOgre::Gui::EntityCreator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createEntity'", NULL);
#endif
  {
   self->createEntity();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: cleanupCreation of class  EmberOgre::Gui::EntityCreator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_EntityCreator_cleanupCreation00
static int tolua_EmberOgre_EmberOgre_Gui_EntityCreator_cleanupCreation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::EntityCreator",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::EntityCreator* self = (EmberOgre::Gui::EntityCreator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cleanupCreation'", NULL);
#endif
  {
   self->cleanupCreation();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'cleanupCreation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: mWidget of class  EmberOgre::Gui::EntityCreator */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__EntityCreator_mWidget_ptr
static int tolua_get_EmberOgre__Gui__EntityCreator_mWidget_ptr(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityCreator* self = (EmberOgre::Gui::EntityCreator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'mWidget'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)self->mWidget,"EmberOgre::Gui::Widget");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: mWidget of class  EmberOgre::Gui::EntityCreator */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__EntityCreator_mWidget_ptr
static int tolua_set_EmberOgre__Gui__EntityCreator_mWidget_ptr(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityCreator* self = (EmberOgre::Gui::EntityCreator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'mWidget'",NULL);
  if (!tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Widget",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->mWidget = ((EmberOgre::Gui::Widget*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventTypeInfoLoaded of class  EmberOgre::Gui::EntityCreator */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__EntityCreator_EventTypeInfoLoaded
static int tolua_get_EmberOgre__Gui__EntityCreator_EventTypeInfoLoaded(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityCreator* self = (EmberOgre::Gui::EntityCreator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventTypeInfoLoaded'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventTypeInfoLoaded,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventTypeInfoLoaded of class  EmberOgre::Gui::EntityCreator */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__EntityCreator_EventTypeInfoLoaded
static int tolua_set_EmberOgre__Gui__EntityCreator_EventTypeInfoLoaded(lua_State* tolua_S)
{
  EmberOgre::Gui::EntityCreator* self = (EmberOgre::Gui::EntityCreator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventTypeInfoLoaded'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventTypeInfoLoaded = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: displayAuthoringVisualization of class  EmberOgre::Authoring::AuthoringManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_displayAuthoringVisualization00
static int tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_displayAuthoringVisualization00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::AuthoringManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::AuthoringManager* self = (EmberOgre::Authoring::AuthoringManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'displayAuthoringVisualization'", NULL);
#endif
  {
   self->displayAuthoringVisualization();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'displayAuthoringVisualization'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hideAuthoringVisualization of class  EmberOgre::Authoring::AuthoringManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_hideAuthoringVisualization00
static int tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_hideAuthoringVisualization00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::AuthoringManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::AuthoringManager* self = (EmberOgre::Authoring::AuthoringManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hideAuthoringVisualization'", NULL);
#endif
  {
   self->hideAuthoringVisualization();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hideAuthoringVisualization'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: displaySimpleEntityVisualization of class  EmberOgre::Authoring::AuthoringManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_displaySimpleEntityVisualization00
static int tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_displaySimpleEntityVisualization00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::AuthoringManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::EmberEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::AuthoringManager* self = (EmberOgre::Authoring::AuthoringManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'displaySimpleEntityVisualization'", NULL);
#endif
  {
   self->displaySimpleEntityVisualization(*entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'displaySimpleEntityVisualization'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hideSimpleEntityVisualization of class  EmberOgre::Authoring::AuthoringManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_hideSimpleEntityVisualization00
static int tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_hideSimpleEntityVisualization00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::AuthoringManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::EmberEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::AuthoringManager* self = (EmberOgre::Authoring::AuthoringManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hideSimpleEntityVisualization'", NULL);
#endif
  {
   self->hideSimpleEntityVisualization(*entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hideSimpleEntityVisualization'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: startMovement of class  EmberOgre::Authoring::AuthoringManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_startMovement00
static int tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_startMovement00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::AuthoringManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::EmberEntity",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"EmberOgre::Authoring::EntityMover",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::AuthoringManager* self = (EmberOgre::Authoring::AuthoringManager*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,2,0));
  EmberOgre::Authoring::EntityMover* mover = ((EmberOgre::Authoring::EntityMover*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'startMovement'", NULL);
#endif
  {
   self->startMovement(*entity,*mover);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'startMovement'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stopMovement of class  EmberOgre::Authoring::AuthoringManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_stopMovement00
static int tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_stopMovement00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::AuthoringManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::AuthoringManager* self = (EmberOgre::Authoring::AuthoringManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'stopMovement'", NULL);
#endif
  {
   self->stopMovement();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stopMovement'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRawTypeInfoRepository of class  EmberOgre::Authoring::AuthoringManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_getRawTypeInfoRepository00
static int tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_getRawTypeInfoRepository00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Authoring::AuthoringManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Authoring::AuthoringManager* self = (const EmberOgre::Authoring::AuthoringManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRawTypeInfoRepository'", NULL);
#endif
  {
   EmberOgre::Authoring::RawTypeInfoRepository* tolua_ret = (EmberOgre::Authoring::RawTypeInfoRepository*)  self->getRawTypeInfoRepository();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Authoring::RawTypeInfoRepository");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRawTypeInfoRepository'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DisplayAuthoringVisualizations of class  EmberOgre::Authoring::AuthoringManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Authoring__AuthoringManager_DisplayAuthoringVisualizations
static int tolua_get_EmberOgre__Authoring__AuthoringManager_DisplayAuthoringVisualizations(lua_State* tolua_S)
{
  EmberOgre::Authoring::AuthoringManager* self = (EmberOgre::Authoring::AuthoringManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DisplayAuthoringVisualizations'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->DisplayAuthoringVisualizations,"const Ember::ConsoleCommandWrapper");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: HideAuthoringVisualizations of class  EmberOgre::Authoring::AuthoringManager */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Authoring__AuthoringManager_HideAuthoringVisualizations
static int tolua_get_EmberOgre__Authoring__AuthoringManager_HideAuthoringVisualizations(lua_State* tolua_S)
{
  EmberOgre::Authoring::AuthoringManager* self = (EmberOgre::Authoring::AuthoringManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'HideAuthoringVisualizations'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->HideAuthoringVisualizations,"const Ember::ConsoleCommandWrapper");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRawTypeData of class  EmberOgre::Authoring::RawTypeInfoRepository */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_RawTypeInfoRepository_getRawTypeData00
static int tolua_EmberOgre_EmberOgre_Authoring_RawTypeInfoRepository_getRawTypeData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Authoring::RawTypeInfoRepository",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Authoring::RawTypeInfoRepository* self = (const EmberOgre::Authoring::RawTypeInfoRepository*)  tolua_tousertype(tolua_S,1,0);
  const std::string typeName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRawTypeData'", NULL);
#endif
  {
   Atlas::Objects::Root tolua_ret = (Atlas::Objects::Root)  self->getRawTypeData(typeName);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Atlas::Objects::Root)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Objects::Root");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Objects::Root));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Objects::Root");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushcppstring(tolua_S,(const char*)typeName);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRawTypeData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Authoring::AtlasObjectDecoder */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_new00
static int tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Authoring::AtlasObjectDecoder",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Authoring::AtlasObjectDecoder* tolua_ret = (EmberOgre::Authoring::AtlasObjectDecoder*)  Mtolua_new((EmberOgre::Authoring::AtlasObjectDecoder)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Authoring::AtlasObjectDecoder");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Authoring::AtlasObjectDecoder */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_new00_local
static int tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Authoring::AtlasObjectDecoder",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Authoring::AtlasObjectDecoder* tolua_ret = (EmberOgre::Authoring::AtlasObjectDecoder*)  Mtolua_new((EmberOgre::Authoring::AtlasObjectDecoder)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Authoring::AtlasObjectDecoder");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Authoring::AtlasObjectDecoder */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_delete00
static int tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::AtlasObjectDecoder",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::AtlasObjectDecoder* self = (EmberOgre::Authoring::AtlasObjectDecoder*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLastObject of class  EmberOgre::Authoring::AtlasObjectDecoder */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_getLastObject00
static int tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_getLastObject00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Authoring::AtlasObjectDecoder",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Authoring::AtlasObjectDecoder* self = (EmberOgre::Authoring::AtlasObjectDecoder*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLastObject'", NULL);
#endif
  {
   Atlas::Objects::Root tolua_ret = (Atlas::Objects::Root)  self->getLastObject();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Atlas::Objects::Root)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Objects::Root");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Objects::Root));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Objects::Root");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLastObject'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventObjectArrived of class  EmberOgre::Authoring::AtlasObjectDecoder */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Authoring__AtlasObjectDecoder_EventObjectArrived
static int tolua_get_EmberOgre__Authoring__AtlasObjectDecoder_EventObjectArrived(lua_State* tolua_S)
{
  EmberOgre::Authoring::AtlasObjectDecoder* self = (EmberOgre::Authoring::AtlasObjectDecoder*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventObjectArrived'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventObjectArrived,"sigc::signal<void,const Atlas::Objects::Root&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  std::vector<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_std__string__clear00
static int tolua_EmberOgre_std_vector_std__string__clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<std::string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<std::string>* self = (std::vector<std::string>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  std::vector<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_std__string__size00
static int tolua_EmberOgre_std_vector_std__string__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<std::string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<std::string>* self = (const std::vector<std::string>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_std__string___geti00
static int tolua_EmberOgre_std_vector_std__string___geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<std::string>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<std::string>* self = (const std::vector<std::string>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->operator[](index);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  std::vector<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_std__string___seti00
static int tolua_EmberOgre_std_vector_std__string___seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<std::string>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<std::string>* self = (std::vector<std::string>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
  std::string tolua_value = ((std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_std__string___geti01
static int tolua_EmberOgre_std_vector_std__string___geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<std::string>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  std::vector<std::string>* self = (std::vector<std::string>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->operator[](index);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_std_vector_std__string___geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  std::vector<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_std__string__push_back00
static int tolua_EmberOgre_std_vector_std__string__push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<std::string>",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<std::string>* self = (std::vector<std::string>*)  tolua_tousertype(tolua_S,1,0);
  std::string val = ((std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(val);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_std__string__new00
static int tolua_EmberOgre_std_vector_std__string__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<std::string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<std::string>* tolua_ret = (std::vector<std::string>*)  Mtolua_new((std::vector<std::string>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<std::string>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_std__string__new00_local
static int tolua_EmberOgre_std_vector_std__string__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<std::string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<std::string>* tolua_ret = (std::vector<std::string>*)  Mtolua_new((std::vector<std::string>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  std::vector<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_std__string__delete00
static int tolua_EmberOgre_std_vector_std__string__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<std::string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<std::string>* self = (std::vector<std::string>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  std::vector<EmberOgre::Model::SubModelDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___clear00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::SubModelDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::Model::SubModelDefinition*>* self = (std::vector<EmberOgre::Model::SubModelDefinition*>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  std::vector<EmberOgre::Model::SubModelDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___size00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<EmberOgre::Model::SubModelDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<EmberOgre::Model::SubModelDefinition*>* self = (const std::vector<EmberOgre::Model::SubModelDefinition*>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<EmberOgre::Model::SubModelDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition____geti00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition____geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<EmberOgre::Model::SubModelDefinition*>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<EmberOgre::Model::SubModelDefinition*>* self = (const std::vector<EmberOgre::Model::SubModelDefinition*>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   const EmberOgre::Model::SubModelDefinition* tolua_ret = (const EmberOgre::Model::SubModelDefinition*)  self->operator[](index);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const EmberOgre::Model::SubModelDefinition");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  std::vector<EmberOgre::Model::SubModelDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition____seti00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition____seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::SubModelDefinition*>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"EmberOgre::Model::SubModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::Model::SubModelDefinition*>* self = (std::vector<EmberOgre::Model::SubModelDefinition*>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
  EmberOgre::Model::SubModelDefinition* tolua_value = ((EmberOgre::Model::SubModelDefinition*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<EmberOgre::Model::SubModelDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition____geti01
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition____geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::SubModelDefinition*>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  std::vector<EmberOgre::Model::SubModelDefinition*>* self = (std::vector<EmberOgre::Model::SubModelDefinition*>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   EmberOgre::Model::SubModelDefinition* tolua_ret = (EmberOgre::Model::SubModelDefinition*)  self->operator[](index);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::SubModelDefinition");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition____geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  std::vector<EmberOgre::Model::SubModelDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___push_back00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::SubModelDefinition*>",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Model::SubModelDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::Model::SubModelDefinition*>* self = (std::vector<EmberOgre::Model::SubModelDefinition*>*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::SubModelDefinition* val = ((EmberOgre::Model::SubModelDefinition*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(val);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<EmberOgre::Model::SubModelDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___new00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<EmberOgre::Model::SubModelDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<EmberOgre::Model::SubModelDefinition*>* tolua_ret = (std::vector<EmberOgre::Model::SubModelDefinition*>*)  Mtolua_new((std::vector<EmberOgre::Model::SubModelDefinition*>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<EmberOgre::Model::SubModelDefinition*>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<EmberOgre::Model::SubModelDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___new00_local
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<EmberOgre::Model::SubModelDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<EmberOgre::Model::SubModelDefinition*>* tolua_ret = (std::vector<EmberOgre::Model::SubModelDefinition*>*)  Mtolua_new((std::vector<EmberOgre::Model::SubModelDefinition*>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<EmberOgre::Model::SubModelDefinition*>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  std::vector<EmberOgre::Model::SubModelDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___delete00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::SubModelDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::Model::SubModelDefinition*>* self = (std::vector<EmberOgre::Model::SubModelDefinition*>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  std::vector<EmberOgre::Model::PartDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___clear00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::PartDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::Model::PartDefinition*>* self = (std::vector<EmberOgre::Model::PartDefinition*>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  std::vector<EmberOgre::Model::PartDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___size00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<EmberOgre::Model::PartDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<EmberOgre::Model::PartDefinition*>* self = (const std::vector<EmberOgre::Model::PartDefinition*>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<EmberOgre::Model::PartDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition____geti00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition____geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<EmberOgre::Model::PartDefinition*>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<EmberOgre::Model::PartDefinition*>* self = (const std::vector<EmberOgre::Model::PartDefinition*>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   const EmberOgre::Model::PartDefinition* tolua_ret = (const EmberOgre::Model::PartDefinition*)  self->operator[](index);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const EmberOgre::Model::PartDefinition");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  std::vector<EmberOgre::Model::PartDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition____seti00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition____seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::PartDefinition*>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"EmberOgre::Model::PartDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::Model::PartDefinition*>* self = (std::vector<EmberOgre::Model::PartDefinition*>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
  EmberOgre::Model::PartDefinition* tolua_value = ((EmberOgre::Model::PartDefinition*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<EmberOgre::Model::PartDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition____geti01
static int tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition____geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::PartDefinition*>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  std::vector<EmberOgre::Model::PartDefinition*>* self = (std::vector<EmberOgre::Model::PartDefinition*>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   EmberOgre::Model::PartDefinition* tolua_ret = (EmberOgre::Model::PartDefinition*)  self->operator[](index);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::PartDefinition");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition____geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  std::vector<EmberOgre::Model::PartDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___push_back00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::PartDefinition*>",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Model::PartDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::Model::PartDefinition*>* self = (std::vector<EmberOgre::Model::PartDefinition*>*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::PartDefinition* val = ((EmberOgre::Model::PartDefinition*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(val);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<EmberOgre::Model::PartDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___new00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<EmberOgre::Model::PartDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<EmberOgre::Model::PartDefinition*>* tolua_ret = (std::vector<EmberOgre::Model::PartDefinition*>*)  Mtolua_new((std::vector<EmberOgre::Model::PartDefinition*>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<EmberOgre::Model::PartDefinition*>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<EmberOgre::Model::PartDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___new00_local
static int tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<EmberOgre::Model::PartDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<EmberOgre::Model::PartDefinition*>* tolua_ret = (std::vector<EmberOgre::Model::PartDefinition*>*)  Mtolua_new((std::vector<EmberOgre::Model::PartDefinition*>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<EmberOgre::Model::PartDefinition*>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  std::vector<EmberOgre::Model::PartDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___delete00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::PartDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::Model::PartDefinition*>* self = (std::vector<EmberOgre::Model::PartDefinition*>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  std::vector<EmberOgre::Model::SubEntityDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___clear00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::SubEntityDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::Model::SubEntityDefinition*>* self = (std::vector<EmberOgre::Model::SubEntityDefinition*>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  std::vector<EmberOgre::Model::SubEntityDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___size00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<EmberOgre::Model::SubEntityDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<EmberOgre::Model::SubEntityDefinition*>* self = (const std::vector<EmberOgre::Model::SubEntityDefinition*>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<EmberOgre::Model::SubEntityDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition____geti00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition____geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<EmberOgre::Model::SubEntityDefinition*>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<EmberOgre::Model::SubEntityDefinition*>* self = (const std::vector<EmberOgre::Model::SubEntityDefinition*>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   const EmberOgre::Model::SubEntityDefinition* tolua_ret = (const EmberOgre::Model::SubEntityDefinition*)  self->operator[](index);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const EmberOgre::Model::SubEntityDefinition");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  std::vector<EmberOgre::Model::SubEntityDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition____seti00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition____seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::SubEntityDefinition*>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"EmberOgre::Model::SubEntityDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::Model::SubEntityDefinition*>* self = (std::vector<EmberOgre::Model::SubEntityDefinition*>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
  EmberOgre::Model::SubEntityDefinition* tolua_value = ((EmberOgre::Model::SubEntityDefinition*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<EmberOgre::Model::SubEntityDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition____geti01
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition____geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::SubEntityDefinition*>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  std::vector<EmberOgre::Model::SubEntityDefinition*>* self = (std::vector<EmberOgre::Model::SubEntityDefinition*>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   EmberOgre::Model::SubEntityDefinition* tolua_ret = (EmberOgre::Model::SubEntityDefinition*)  self->operator[](index);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Model::SubEntityDefinition");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition____geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  std::vector<EmberOgre::Model::SubEntityDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___push_back00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::SubEntityDefinition*>",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Model::SubEntityDefinition",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::Model::SubEntityDefinition*>* self = (std::vector<EmberOgre::Model::SubEntityDefinition*>*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Model::SubEntityDefinition* val = ((EmberOgre::Model::SubEntityDefinition*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(val);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<EmberOgre::Model::SubEntityDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___new00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<EmberOgre::Model::SubEntityDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<EmberOgre::Model::SubEntityDefinition*>* tolua_ret = (std::vector<EmberOgre::Model::SubEntityDefinition*>*)  Mtolua_new((std::vector<EmberOgre::Model::SubEntityDefinition*>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<EmberOgre::Model::SubEntityDefinition*>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<EmberOgre::Model::SubEntityDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___new00_local
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<EmberOgre::Model::SubEntityDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<EmberOgre::Model::SubEntityDefinition*>* tolua_ret = (std::vector<EmberOgre::Model::SubEntityDefinition*>*)  Mtolua_new((std::vector<EmberOgre::Model::SubEntityDefinition*>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<EmberOgre::Model::SubEntityDefinition*>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  std::vector<EmberOgre::Model::SubEntityDefinition*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___delete00
static int tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::Model::SubEntityDefinition*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::Model::SubEntityDefinition*>* self = (std::vector<EmberOgre::Model::SubEntityDefinition*>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  std::vector<Eris::Task*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_Eris__Task___clear00
static int tolua_EmberOgre_std_vector_Eris__Task___clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<Eris::Task*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<Eris::Task*>* self = (std::vector<Eris::Task*>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  std::vector<Eris::Task*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_Eris__Task___size00
static int tolua_EmberOgre_std_vector_Eris__Task___size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<Eris::Task*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<Eris::Task*>* self = (const std::vector<Eris::Task*>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<Eris::Task*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_Eris__Task____geti00
static int tolua_EmberOgre_std_vector_Eris__Task____geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<Eris::Task*>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<Eris::Task*>* self = (const std::vector<Eris::Task*>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   const Eris::Task* tolua_ret = (const Eris::Task*)  self->operator[](index);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const Eris::Task");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  std::vector<Eris::Task*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_Eris__Task____seti00
static int tolua_EmberOgre_std_vector_Eris__Task____seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<Eris::Task*>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"Eris::Task",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<Eris::Task*>* self = (std::vector<Eris::Task*>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
  Eris::Task* tolua_value = ((Eris::Task*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<Eris::Task*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_Eris__Task____geti01
static int tolua_EmberOgre_std_vector_Eris__Task____geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<Eris::Task*>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  std::vector<Eris::Task*>* self = (std::vector<Eris::Task*>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   Eris::Task* tolua_ret = (Eris::Task*)  self->operator[](index);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Eris::Task");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_std_vector_Eris__Task____geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  std::vector<Eris::Task*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_Eris__Task___push_back00
static int tolua_EmberOgre_std_vector_Eris__Task___push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<Eris::Task*>",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Task",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<Eris::Task*>* self = (std::vector<Eris::Task*>*)  tolua_tousertype(tolua_S,1,0);
  Eris::Task* val = ((Eris::Task*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(val);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<Eris::Task*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_Eris__Task___new00
static int tolua_EmberOgre_std_vector_Eris__Task___new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<Eris::Task*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<Eris::Task*>* tolua_ret = (std::vector<Eris::Task*>*)  Mtolua_new((std::vector<Eris::Task*>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<Eris::Task*>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<Eris::Task*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_Eris__Task___new00_local
static int tolua_EmberOgre_std_vector_Eris__Task___new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<Eris::Task*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<Eris::Task*>* tolua_ret = (std::vector<Eris::Task*>*)  Mtolua_new((std::vector<Eris::Task*>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<Eris::Task*>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  std::vector<Eris::Task*> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_Eris__Task___delete00
static int tolua_EmberOgre_std_vector_Eris__Task___delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<Eris::Task*>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<Eris::Task*>* self = (std::vector<Eris::Task*>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  std::vector<EmberOgre::EntityPickResult> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__clear00
static int tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::EntityPickResult>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::EntityPickResult>* self = (std::vector<EmberOgre::EntityPickResult>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  std::vector<EmberOgre::EntityPickResult> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__size00
static int tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<EmberOgre::EntityPickResult>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<EmberOgre::EntityPickResult>* self = (const std::vector<EmberOgre::EntityPickResult>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<EmberOgre::EntityPickResult> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult___geti00
static int tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult___geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<EmberOgre::EntityPickResult>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<EmberOgre::EntityPickResult>* self = (const std::vector<EmberOgre::EntityPickResult>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   const EmberOgre::EntityPickResult tolua_ret = (const EmberOgre::EntityPickResult)  self->operator[](index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((EmberOgre::EntityPickResult)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"const EmberOgre::EntityPickResult");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const EmberOgre::EntityPickResult));
     tolua_pushusertype(tolua_S,tolua_obj,"const EmberOgre::EntityPickResult");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  std::vector<EmberOgre::EntityPickResult> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult___seti00
static int tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult___seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::EntityPickResult>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"EmberOgre::EntityPickResult",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::EntityPickResult>* self = (std::vector<EmberOgre::EntityPickResult>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
  EmberOgre::EntityPickResult tolua_value = *((EmberOgre::EntityPickResult*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<EmberOgre::EntityPickResult> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult___geti01
static int tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult___geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::EntityPickResult>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  std::vector<EmberOgre::EntityPickResult>* self = (std::vector<EmberOgre::EntityPickResult>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
#endif
  {
   EmberOgre::EntityPickResult tolua_ret = (EmberOgre::EntityPickResult)  self->operator[](index);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((EmberOgre::EntityPickResult)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::EntityPickResult");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(EmberOgre::EntityPickResult));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::EntityPickResult");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult___geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  std::vector<EmberOgre::EntityPickResult> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__push_back00
static int tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::EntityPickResult>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"EmberOgre::EntityPickResult",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::EntityPickResult>* self = (std::vector<EmberOgre::EntityPickResult>*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::EntityPickResult val = *((EmberOgre::EntityPickResult*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
#endif
  {
   self->push_back(val);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<EmberOgre::EntityPickResult> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__new00
static int tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<EmberOgre::EntityPickResult>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<EmberOgre::EntityPickResult>* tolua_ret = (std::vector<EmberOgre::EntityPickResult>*)  Mtolua_new((std::vector<EmberOgre::EntityPickResult>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<EmberOgre::EntityPickResult>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<EmberOgre::EntityPickResult> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__new00_local
static int tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<EmberOgre::EntityPickResult>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<EmberOgre::EntityPickResult>* tolua_ret = (std::vector<EmberOgre::EntityPickResult>*)  Mtolua_new((std::vector<EmberOgre::EntityPickResult>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<EmberOgre::EntityPickResult>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  std::vector<EmberOgre::EntityPickResult> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__delete00
static int tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<EmberOgre::EntityPickResult>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<EmberOgre::EntityPickResult>* self = (std::vector<EmberOgre::EntityPickResult>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  std::set<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_set_std__string__clear00
static int tolua_EmberOgre_std_set_std__string__clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::set<std::string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::set<std::string>* self = (std::set<std::string>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  std::set<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_set_std__string__size00
static int tolua_EmberOgre_std_set_std__string__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::set<std::string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::set<std::string>* self = (const std::set<std::string>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::set<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_set_std__string__new00
static int tolua_EmberOgre_std_set_std__string__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::set<std::string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::set<std::string>* tolua_ret = (std::set<std::string>*)  Mtolua_new((std::set<std::string>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::set<std::string>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::set<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_set_std__string__new00_local
static int tolua_EmberOgre_std_set_std__string__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::set<std::string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::set<std::string>* tolua_ret = (std::set<std::string>*)  Mtolua_new((std::set<std::string>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::set<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  std::set<std::string> */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_std_set_std__string__delete00
static int tolua_EmberOgre_std_set_std__string__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::set<std::string>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::set<std::string>* self = (std::set<std::string>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Vector3Adapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new00
static int tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Vector3Adapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const Ogre::Vector3",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  const Ogre::Vector3* vector = ((const Ogre::Vector3*)  tolua_tousertype(tolua_S,5,0));
  {
   EmberOgre::Gui::Vector3Adapter* tolua_ret = (EmberOgre::Gui::Vector3Adapter*)  Mtolua_new((EmberOgre::Gui::Vector3Adapter)(xWindow,yWindow,zWindow,*vector));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Vector3Adapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Vector3Adapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Vector3Adapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const Ogre::Vector3",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  const Ogre::Vector3* vector = ((const Ogre::Vector3*)  tolua_tousertype(tolua_S,5,0));
  {
   EmberOgre::Gui::Vector3Adapter* tolua_ret = (EmberOgre::Gui::Vector3Adapter*)  Mtolua_new((EmberOgre::Gui::Vector3Adapter)(xWindow,yWindow,zWindow,*vector));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Vector3Adapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Vector3Adapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new01
static int tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Vector3Adapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  {
   EmberOgre::Gui::Vector3Adapter* tolua_ret = (EmberOgre::Gui::Vector3Adapter*)  Mtolua_new((EmberOgre::Gui::Vector3Adapter)(xWindow,yWindow,zWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Vector3Adapter");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Vector3Adapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new01_local
static int tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Vector3Adapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  {
   EmberOgre::Gui::Vector3Adapter* tolua_ret = (EmberOgre::Gui::Vector3Adapter*)  Mtolua_new((EmberOgre::Gui::Vector3Adapter)(xWindow,yWindow,zWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Vector3Adapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Vector3Adapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_delete00
static int tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Vector3Adapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Vector3Adapter* self = (EmberOgre::Gui::Vector3Adapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getValue of class  EmberOgre::Gui::Vector3Adapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_getValue00
static int tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_getValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Vector3Adapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Vector3Adapter* self = (const EmberOgre::Gui::Vector3Adapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValue'", NULL);
#endif
  {
   const Ogre::Vector3& tolua_ret = (const Ogre::Vector3&)  self->getValue();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Ogre::Vector3");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOriginalValue of class  EmberOgre::Gui::Vector3Adapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_getOriginalValue00
static int tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_getOriginalValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Vector3Adapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Vector3Adapter* self = (const EmberOgre::Gui::Vector3Adapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOriginalValue'", NULL);
#endif
  {
   const Ogre::Vector3& tolua_ret = (const Ogre::Vector3&)  self->getOriginalValue();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Ogre::Vector3");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOriginalValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setValue of class  EmberOgre::Gui::Vector3Adapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_setValue00
static int tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_setValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Vector3Adapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Vector3",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Vector3Adapter* self = (EmberOgre::Gui::Vector3Adapter*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::Vector3* vector = ((const Ogre::Vector3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValue'", NULL);
#endif
  {
   self->setValue(*vector);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: updateGui of class  EmberOgre::Gui::Vector3Adapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_updateGui00
static int tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_updateGui00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Vector3Adapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Vector3",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Vector3Adapter* self = (EmberOgre::Gui::Vector3Adapter*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::Vector3* vector = ((const Ogre::Vector3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'updateGui'", NULL);
#endif
  {
   self->updateGui(*vector);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'updateGui'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventValueChanged of class  EmberOgre::Gui::Vector3Adapter */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__Vector3Adapter_EventValueChanged
static int tolua_get_EmberOgre__Gui__Vector3Adapter_EventValueChanged(lua_State* tolua_S)
{
  EmberOgre::Gui::Vector3Adapter* self = (EmberOgre::Gui::Vector3Adapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventValueChanged'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventValueChanged,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventValueChanged of class  EmberOgre::Gui::Vector3Adapter */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__Vector3Adapter_EventValueChanged
static int tolua_set_EmberOgre__Gui__Vector3Adapter_EventValueChanged(lua_State* tolua_S)
{
  EmberOgre::Gui::Vector3Adapter* self = (EmberOgre::Gui::Vector3Adapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventValueChanged'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventValueChanged = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new00
static int tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::QuaternionAdapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* degreeWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,5,0));
  {
   EmberOgre::Gui::QuaternionAdapter* tolua_ret = (EmberOgre::Gui::QuaternionAdapter*)  Mtolua_new((EmberOgre::Gui::QuaternionAdapter)(degreeWindow,xWindow,yWindow,zWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::QuaternionAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new00_local
static int tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::QuaternionAdapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* degreeWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,5,0));
  {
   EmberOgre::Gui::QuaternionAdapter* tolua_ret = (EmberOgre::Gui::QuaternionAdapter*)  Mtolua_new((EmberOgre::Gui::QuaternionAdapter)(degreeWindow,xWindow,yWindow,zWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::QuaternionAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new01
static int tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::QuaternionAdapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Window",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"const Ogre::Quaternion",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  CEGUI::Window* degreeWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,5,0));
  const Ogre::Quaternion* quaternion = ((const Ogre::Quaternion*)  tolua_tousertype(tolua_S,6,0));
  {
   EmberOgre::Gui::QuaternionAdapter* tolua_ret = (EmberOgre::Gui::QuaternionAdapter*)  Mtolua_new((EmberOgre::Gui::QuaternionAdapter)(degreeWindow,xWindow,yWindow,zWindow,*quaternion));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::QuaternionAdapter");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new01_local
static int tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::QuaternionAdapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Window",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"const Ogre::Quaternion",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  CEGUI::Window* degreeWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,5,0));
  const Ogre::Quaternion* quaternion = ((const Ogre::Quaternion*)  tolua_tousertype(tolua_S,6,0));
  {
   EmberOgre::Gui::QuaternionAdapter* tolua_ret = (EmberOgre::Gui::QuaternionAdapter*)  Mtolua_new((EmberOgre::Gui::QuaternionAdapter)(degreeWindow,xWindow,yWindow,zWindow,*quaternion));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::QuaternionAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new02
static int tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::QuaternionAdapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  CEGUI::Window* degreeWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,5,0));
  {
   EmberOgre::Gui::QuaternionAdapter* tolua_ret = (EmberOgre::Gui::QuaternionAdapter*)  Mtolua_new((EmberOgre::Gui::QuaternionAdapter)(degreeWindow,xWindow,yWindow,zWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::QuaternionAdapter");
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new02_local
static int tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::QuaternionAdapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  CEGUI::Window* degreeWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,5,0));
  {
   EmberOgre::Gui::QuaternionAdapter* tolua_ret = (EmberOgre::Gui::QuaternionAdapter*)  Mtolua_new((EmberOgre::Gui::QuaternionAdapter)(degreeWindow,xWindow,yWindow,zWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::QuaternionAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_delete00
static int tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::QuaternionAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::QuaternionAdapter* self = (EmberOgre::Gui::QuaternionAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getValue of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_getValue00
static int tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_getValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::QuaternionAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::QuaternionAdapter* self = (const EmberOgre::Gui::QuaternionAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValue'", NULL);
#endif
  {
   const Ogre::Quaternion& tolua_ret = (const Ogre::Quaternion&)  self->getValue();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Ogre::Quaternion");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOriginalValue of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_getOriginalValue00
static int tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_getOriginalValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::QuaternionAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::QuaternionAdapter* self = (const EmberOgre::Gui::QuaternionAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOriginalValue'", NULL);
#endif
  {
   const Ogre::Quaternion& tolua_ret = (const Ogre::Quaternion&)  self->getOriginalValue();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Ogre::Quaternion");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOriginalValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setValue of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_setValue00
static int tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_setValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::QuaternionAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Quaternion",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::QuaternionAdapter* self = (EmberOgre::Gui::QuaternionAdapter*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::Quaternion* quaternion = ((const Ogre::Quaternion*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValue'", NULL);
#endif
  {
   self->setValue(*quaternion);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: updateGui of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_updateGui00
static int tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_updateGui00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::QuaternionAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ogre::Quaternion",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::QuaternionAdapter* self = (EmberOgre::Gui::QuaternionAdapter*)  tolua_tousertype(tolua_S,1,0);
  const Ogre::Quaternion* vector = ((const Ogre::Quaternion*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'updateGui'", NULL);
#endif
  {
   self->updateGui(*vector);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'updateGui'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventValueChanged of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__QuaternionAdapter_EventValueChanged
static int tolua_get_EmberOgre__Gui__QuaternionAdapter_EventValueChanged(lua_State* tolua_S)
{
  EmberOgre::Gui::QuaternionAdapter* self = (EmberOgre::Gui::QuaternionAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventValueChanged'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventValueChanged,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventValueChanged of class  EmberOgre::Gui::QuaternionAdapter */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__QuaternionAdapter_EventValueChanged
static int tolua_set_EmberOgre__Gui__QuaternionAdapter_EventValueChanged(lua_State* tolua_S)
{
  EmberOgre::Gui::QuaternionAdapter* self = (EmberOgre::Gui::QuaternionAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventValueChanged'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventValueChanged = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_new00
static int tolua_EmberOgre_EmberOgre_Terrain_Map_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Terrain::Map",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::SceneManager",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ogre::SceneManager* sceneManager = ((Ogre::SceneManager*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Terrain::Map* tolua_ret = (EmberOgre::Terrain::Map*)  Mtolua_new((EmberOgre::Terrain::Map)(*sceneManager));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Terrain::Map");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_new00_local
static int tolua_EmberOgre_EmberOgre_Terrain_Map_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Terrain::Map",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::SceneManager",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ogre::SceneManager* sceneManager = ((Ogre::SceneManager*)  tolua_tousertype(tolua_S,2,0));
  {
   EmberOgre::Terrain::Map* tolua_ret = (EmberOgre::Terrain::Map*)  Mtolua_new((EmberOgre::Terrain::Map)(*sceneManager));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Terrain::Map");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_delete00
static int tolua_EmberOgre_EmberOgre_Terrain_Map_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::Map",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::Map* self = (EmberOgre::Terrain::Map*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initialize of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_initialize00
static int tolua_EmberOgre_EmberOgre_Terrain_Map_initialize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::Map",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::Map* self = (EmberOgre::Terrain::Map*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initialize'", NULL);
#endif
  {
   self->initialize();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initialize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTexture of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_getTexture00
static int tolua_EmberOgre_EmberOgre_Terrain_Map_getTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::Map",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::Map* self = (EmberOgre::Terrain::Map*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTexture'", NULL);
#endif
  {
   Ogre::TexturePtr tolua_ret = (Ogre::TexturePtr)  self->getTexture();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Ogre::TexturePtr)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::TexturePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Ogre::TexturePtr));
     tolua_pushusertype(tolua_S,tolua_obj,"Ogre::TexturePtr");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_render00
static int tolua_EmberOgre_EmberOgre_Terrain_Map_render00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::Map",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::Map* self = (EmberOgre::Terrain::Map*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'", NULL);
#endif
  {
   self->render();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'render'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reposition of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_reposition00
static int tolua_EmberOgre_EmberOgre_Terrain_Map_reposition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::Map",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::Vector2",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::Map* self = (EmberOgre::Terrain::Map*)  tolua_tousertype(tolua_S,1,0);
  Ogre::Vector2 pos = *((Ogre::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reposition'", NULL);
#endif
  {
   self->reposition(pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reposition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reposition of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_reposition01
static int tolua_EmberOgre_EmberOgre_Terrain_Map_reposition01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::Map",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::Terrain::Map* self = (EmberOgre::Terrain::Map*)  tolua_tousertype(tolua_S,1,0);
  float x = ((float)  tolua_tonumber(tolua_S,2,0));
  float y = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reposition'", NULL);
#endif
  {
   self->reposition(x,y);
  }
 }
 return 0;
tolua_lerror:
 return tolua_EmberOgre_EmberOgre_Terrain_Map_reposition00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDistance of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_setDistance00
static int tolua_EmberOgre_EmberOgre_Terrain_Map_setDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::Map",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::Map* self = (EmberOgre::Terrain::Map*)  tolua_tousertype(tolua_S,1,0);
  float distance = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDistance'", NULL);
#endif
  {
   self->setDistance(distance);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDistance of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_getDistance00
static int tolua_EmberOgre_EmberOgre_Terrain_Map_getDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::Map",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::Map* self = (const EmberOgre::Terrain::Map*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDistance'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getDistance();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getResolution of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_getResolution00
static int tolua_EmberOgre_EmberOgre_Terrain_Map_getResolution00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::Map",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::Map* self = (const EmberOgre::Terrain::Map*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getResolution'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getResolution();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getResolution'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setResolution of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_setResolution00
static int tolua_EmberOgre_EmberOgre_Terrain_Map_setResolution00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::Map",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::Map* self = (EmberOgre::Terrain::Map*)  tolua_tousertype(tolua_S,1,0);
  float metersPerPixel = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setResolution'", NULL);
#endif
  {
   self->setResolution(metersPerPixel);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setResolution'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getResolutionMeters of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_getResolutionMeters00
static int tolua_EmberOgre_EmberOgre_Terrain_Map_getResolutionMeters00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::Map",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::Map* self = (const EmberOgre::Terrain::Map*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getResolutionMeters'", NULL);
#endif
  {
   float tolua_ret = (float)  self->getResolutionMeters();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getResolutionMeters'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getView of class  EmberOgre::Terrain::Map */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_Map_getView00
static int tolua_EmberOgre_EmberOgre_Terrain_Map_getView00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::Map",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::Map* self = (EmberOgre::Terrain::Map*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getView'", NULL);
#endif
  {
   EmberOgre::Terrain::MapView& tolua_ret = (EmberOgre::Terrain::MapView&)  self->getView();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Terrain::MapView");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getView'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reposition of class  EmberOgre::Terrain::MapView */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_MapView_reposition00
static int tolua_EmberOgre_EmberOgre_Terrain_MapView_reposition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::MapView",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::Vector2",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::MapView* self = (EmberOgre::Terrain::MapView*)  tolua_tousertype(tolua_S,1,0);
  Ogre::Vector2 pos = *((Ogre::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reposition'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->reposition(pos);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reposition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRelativeViewBounds of class  EmberOgre::Terrain::MapView */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_MapView_getRelativeViewBounds00
static int tolua_EmberOgre_EmberOgre_Terrain_MapView_getRelativeViewBounds00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::MapView",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::MapView* self = (const EmberOgre::Terrain::MapView*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRelativeViewBounds'", NULL);
#endif
  {
   const Ogre::TRect<float>& tolua_ret = (const Ogre::TRect<float>&)  self->getRelativeViewBounds();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Ogre::TRect<float>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRelativeViewBounds'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isIndirect of class  EmberOgre::OgreInfo */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_OgreInfo_isIndirect00
static int tolua_EmberOgre_EmberOgre_OgreInfo_isIndirect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::OgreInfo",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   bool tolua_ret = (bool)  EmberOgre::OgreInfo::isIndirect();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isIndirect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createUniqueResourceName of class  EmberOgre::OgreInfo */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_OgreInfo_createUniqueResourceName00
static int tolua_EmberOgre_EmberOgre_OgreInfo_createUniqueResourceName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::OgreInfo",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string resourceName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   std::string tolua_ret = (std::string)  EmberOgre::OgreInfo::createUniqueResourceName(resourceName);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)resourceName);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createUniqueResourceName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_ptr of class  const_iterator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_const_iterator_get00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_const_iterator_get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator* self = (EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_ptr'", NULL);
#endif
  {
   EmberOgre::Terrain::TerrainLayerDefinition* tolua_ret = (EmberOgre::Terrain::TerrainLayerDefinition*)  self->__operator_ptr();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Terrain::TerrainLayerDefinition");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_pp of class  const_iterator */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_const_iterator_next00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_const_iterator_next00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator* self = (EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_pp'", NULL);
#endif
  {
   EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator& tolua_ret = (EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator&)  self->__operator_pp();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: begin of class  DefinitionStore */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_begin00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_begin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore* self = (const EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'begin'", NULL);
#endif
  {
   EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator tolua_ret = (EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator)  self->begin();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'begin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: end of class  DefinitionStore */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_theEnd00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_theEnd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore* self = (const EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'end'", NULL);
#endif
  {
   EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator tolua_ret = (EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator)  self->end();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator));
     tolua_pushusertype(tolua_S,tolua_obj,"EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'theEnd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  DefinitionStore */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_size00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore* self = (const EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  EmberOgre::Terrain::TerrainLayerDefinitionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_getSingleton00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Terrain::TerrainLayerDefinitionManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::Terrain::TerrainLayerDefinitionManager& tolua_ret = (EmberOgre::Terrain::TerrainLayerDefinitionManager&)  EmberOgre::Terrain::TerrainLayerDefinitionManager::getSingleton();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Terrain::TerrainLayerDefinitionManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: parseScript of class  EmberOgre::Terrain::TerrainLayerDefinitionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_parseScript00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_parseScript00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainLayerDefinitionManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ogre::DataStreamPtr",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const Ogre::String",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainLayerDefinitionManager* self = (EmberOgre::Terrain::TerrainLayerDefinitionManager*)  tolua_tousertype(tolua_S,1,0);
  Ogre::DataStreamPtr* stream = ((Ogre::DataStreamPtr*)  tolua_tousertype(tolua_S,2,0));
  const Ogre::String* groupName = ((const Ogre::String*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'parseScript'", NULL);
#endif
  {
   self->parseScript(*stream,*groupName);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'parseScript'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefinitions of class  EmberOgre::Terrain::TerrainLayerDefinitionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_getDefinitions00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_getDefinitions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Terrain::TerrainLayerDefinitionManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Terrain::TerrainLayerDefinitionManager* self = (const EmberOgre::Terrain::TerrainLayerDefinitionManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefinitions'", NULL);
#endif
  {
   const EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore& tolua_ret = (const EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore&)  self->getDefinitions();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefinitions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefinitionForArea of class  EmberOgre::Terrain::TerrainLayerDefinitionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_getDefinitionForArea00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_getDefinitionForArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainLayerDefinitionManager",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainLayerDefinitionManager* self = (EmberOgre::Terrain::TerrainLayerDefinitionManager*)  tolua_tousertype(tolua_S,1,0);
  unsigned int areaIndex = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefinitionForArea'", NULL);
#endif
  {
   EmberOgre::Terrain::TerrainLayerDefinition* tolua_ret = (EmberOgre::Terrain::TerrainLayerDefinition*)  self->getDefinitionForArea(areaIndex);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Terrain::TerrainLayerDefinition");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefinitionForArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefinitionForShader of class  EmberOgre::Terrain::TerrainLayerDefinitionManager */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_getDefinitionForShader00
static int tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_getDefinitionForShader00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Terrain::TerrainLayerDefinitionManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Terrain::TerrainLayerDefinitionManager* self = (EmberOgre::Terrain::TerrainLayerDefinitionManager*)  tolua_tousertype(tolua_S,1,0);
  const std::string shaderType = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefinitionForShader'", NULL);
#endif
  {
   EmberOgre::Terrain::TerrainLayerDefinition* tolua_ret = (EmberOgre::Terrain::TerrainLayerDefinition*)  self->getDefinitionForShader(shaderType);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Terrain::TerrainLayerDefinition");
   tolua_pushcppstring(tolua_S,(const char*)shaderType);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefinitionForShader'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSceneManager of class  EmberOgre::World */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_World_getSceneManager00
static int tolua_EmberOgre_EmberOgre_World_getSceneManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::World",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::World* self = (const EmberOgre::World*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSceneManager'", NULL);
#endif
  {
   Ogre::SceneManager& tolua_ret = (Ogre::SceneManager&)  self->getSceneManager();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ogre::SceneManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSceneManager'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getView of class  EmberOgre::World */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_World_getView00
static int tolua_EmberOgre_EmberOgre_World_getView00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::World",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::World* self = (const EmberOgre::World*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getView'", NULL);
#endif
  {
   Eris::View& tolua_ret = (Eris::View&)  self->getView();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Eris::View");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getView'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAvatar of class  EmberOgre::World */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_World_getAvatar00
static int tolua_EmberOgre_EmberOgre_World_getAvatar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::World",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::World* self = (const EmberOgre::World*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAvatar'", NULL);
#endif
  {
   EmberOgre::Avatar* tolua_ret = (EmberOgre::Avatar*)  self->getAvatar();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Avatar");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAvatar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMotionManager of class  EmberOgre::World */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_World_getMotionManager00
static int tolua_EmberOgre_EmberOgre_World_getMotionManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::World",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::World* self = (const EmberOgre::World*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMotionManager'", NULL);
#endif
  {
   EmberOgre::MotionManager& tolua_ret = (EmberOgre::MotionManager&)  self->getMotionManager();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::MotionManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMotionManager'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEntityFactory of class  EmberOgre::World */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_World_getEntityFactory00
static int tolua_EmberOgre_EmberOgre_World_getEntityFactory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::World",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::World* self = (const EmberOgre::World*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEntityFactory'", NULL);
#endif
  {
   EmberOgre::EmberEntityFactory& tolua_ret = (EmberOgre::EmberEntityFactory&)  self->getEntityFactory();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::EmberEntityFactory");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEntityFactory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMainCamera of class  EmberOgre::World */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_World_getMainCamera00
static int tolua_EmberOgre_EmberOgre_World_getMainCamera00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::World",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::World* self = (const EmberOgre::World*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMainCamera'", NULL);
#endif
  {
   EmberOgre::Camera::MainCamera& tolua_ret = (EmberOgre::Camera::MainCamera&)  self->getMainCamera();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Camera::MainCamera");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMainCamera'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMovementController of class  EmberOgre::World */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_World_getMovementController00
static int tolua_EmberOgre_EmberOgre_World_getMovementController00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::World",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::World* self = (const EmberOgre::World*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMovementController'", NULL);
#endif
  {
   EmberOgre::MovementController* tolua_ret = (EmberOgre::MovementController*)  self->getMovementController();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::MovementController");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMovementController'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMoveManager of class  EmberOgre::World */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_World_getMoveManager00
static int tolua_EmberOgre_EmberOgre_World_getMoveManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::World",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::World* self = (const EmberOgre::World*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMoveManager'", NULL);
#endif
  {
   EmberOgre::Authoring::EntityMoveManager& tolua_ret = (EmberOgre::Authoring::EntityMoveManager&)  self->getMoveManager();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Authoring::EntityMoveManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMoveManager'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEmberEntity of class  EmberOgre::World */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_World_getEmberEntity00
static int tolua_EmberOgre_EmberOgre_World_getEmberEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::World",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::World* self = (const EmberOgre::World*)  tolua_tousertype(tolua_S,1,0);
  const std::string eid = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEmberEntity'", NULL);
#endif
  {
   EmberOgre::EmberEntity* tolua_ret = (EmberOgre::EmberEntity*)  self->getEmberEntity(eid);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::EmberEntity");
   tolua_pushcppstring(tolua_S,(const char*)eid);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEmberEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEntityPickListener of class  EmberOgre::World */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_World_getEntityPickListener00
static int tolua_EmberOgre_EmberOgre_World_getEntityPickListener00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::World",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::World* self = (const EmberOgre::World*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEntityPickListener'", NULL);
#endif
  {
   EmberOgre::EntityWorldPickListener& tolua_ret = (EmberOgre::EntityWorldPickListener&)  self->getEntityPickListener();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::EntityWorldPickListener");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEntityPickListener'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAuthoringManager of class  EmberOgre::World */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_World_getAuthoringManager00
static int tolua_EmberOgre_EmberOgre_World_getAuthoringManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::World",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::World* self = (const EmberOgre::World*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAuthoringManager'", NULL);
#endif
  {
   EmberOgre::Authoring::AuthoringManager& tolua_ret = (EmberOgre::Authoring::AuthoringManager&)  self->getAuthoringManager();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::Authoring::AuthoringManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAuthoringManager'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSceneManager of class  EmberOgre::Scene */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Scene_getSceneManager00
static int tolua_EmberOgre_EmberOgre_Scene_getSceneManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Scene",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Scene* self = (const EmberOgre::Scene*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSceneManager'", NULL);
#endif
  {
   Ogre::SceneManager& tolua_ret = (Ogre::SceneManager&)  self->getSceneManager();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ogre::SceneManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSceneManager'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMainCamera of class  EmberOgre::Scene */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_Scene_getMainCamera00
static int tolua_EmberOgre_EmberOgre_Scene_getMainCamera00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Scene",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Scene* self = (const EmberOgre::Scene*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMainCamera'", NULL);
#endif
  {
   Ogre::Camera& tolua_ret = (Ogre::Camera&)  self->getMainCamera();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ogre::Camera");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMainCamera'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberOgre_getSingleton00
static int tolua_EmberOgre_EmberOgre_EmberOgre_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::EmberOgre",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   EmberOgre::EmberOgre& tolua_ret = (EmberOgre::EmberOgre&)  EmberOgre::EmberOgre::getSingleton();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"EmberOgre::EmberOgre");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWorld of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberOgre_getWorld00
static int tolua_EmberOgre_EmberOgre_EmberOgre_getWorld00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::EmberOgre",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::EmberOgre* self = (const EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWorld'", NULL);
#endif
  {
   EmberOgre::World* tolua_ret = (EmberOgre::World*)  self->getWorld();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::World");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWorld'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRenderWindow of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_EmberOgre_EmberOgre_EmberOgre_getRenderWindow00
static int tolua_EmberOgre_EmberOgre_EmberOgre_getRenderWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::EmberOgre",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::EmberOgre* self = (const EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRenderWindow'", NULL);
#endif
  {
   Ogre::RenderWindow* tolua_ret = (Ogre::RenderWindow*)  self->getRenderWindow();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ogre::RenderWindow");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRenderWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventCreatedEmberEntityFactory of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventCreatedEmberEntityFactory
static int tolua_get_EmberOgre__EmberOgre_EventCreatedEmberEntityFactory(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventCreatedEmberEntityFactory'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventCreatedEmberEntityFactory,"sigc::signal<void,EmberOgre::EmberEntityFactory&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventCreatedEmberEntityFactory of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventCreatedEmberEntityFactory
static int tolua_set_EmberOgre__EmberOgre_EventCreatedEmberEntityFactory(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventCreatedEmberEntityFactory'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::EmberEntityFactory&>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventCreatedEmberEntityFactory = *((sigc::signal<void,EmberOgre::EmberEntityFactory&>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventCreatedAvatarEntity of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventCreatedAvatarEntity
static int tolua_get_EmberOgre__EmberOgre_EventCreatedAvatarEntity(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventCreatedAvatarEntity'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventCreatedAvatarEntity,"sigc::signal<void,EmberOgre::EmberEntity&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventCreatedAvatarEntity of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventCreatedAvatarEntity
static int tolua_set_EmberOgre__EmberOgre_EventCreatedAvatarEntity(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventCreatedAvatarEntity'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::EmberEntity&>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventCreatedAvatarEntity = *((sigc::signal<void,EmberOgre::EmberEntity&>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventGUIManagerCreated of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventGUIManagerCreated
static int tolua_get_EmberOgre__EmberOgre_EventGUIManagerCreated(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventGUIManagerCreated'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventGUIManagerCreated,"sigc::signal<void,EmberOgre::GUIManager&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventGUIManagerCreated of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventGUIManagerCreated
static int tolua_set_EmberOgre__EmberOgre_EventGUIManagerCreated(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventGUIManagerCreated'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::GUIManager&>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventGUIManagerCreated = *((sigc::signal<void,EmberOgre::GUIManager&>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventGUIManagerInitialized of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventGUIManagerInitialized
static int tolua_get_EmberOgre__EmberOgre_EventGUIManagerInitialized(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventGUIManagerInitialized'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventGUIManagerInitialized,"sigc::signal<void,EmberOgre::GUIManager&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventGUIManagerInitialized of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventGUIManagerInitialized
static int tolua_set_EmberOgre__EmberOgre_EventGUIManagerInitialized(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventGUIManagerInitialized'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::GUIManager&>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventGUIManagerInitialized = *((sigc::signal<void,EmberOgre::GUIManager&>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventGUIManagerBeingDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventGUIManagerBeingDestroyed
static int tolua_get_EmberOgre__EmberOgre_EventGUIManagerBeingDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventGUIManagerBeingDestroyed'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventGUIManagerBeingDestroyed,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventGUIManagerBeingDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventGUIManagerBeingDestroyed
static int tolua_set_EmberOgre__EmberOgre_EventGUIManagerBeingDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventGUIManagerBeingDestroyed'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventGUIManagerBeingDestroyed = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventGUIManagerDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventGUIManagerDestroyed
static int tolua_get_EmberOgre__EmberOgre_EventGUIManagerDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventGUIManagerDestroyed'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventGUIManagerDestroyed,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventGUIManagerDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventGUIManagerDestroyed
static int tolua_set_EmberOgre__EmberOgre_EventGUIManagerDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventGUIManagerDestroyed'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventGUIManagerDestroyed = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventOgreBeingDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventOgreBeingDestroyed
static int tolua_get_EmberOgre__EmberOgre_EventOgreBeingDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventOgreBeingDestroyed'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventOgreBeingDestroyed,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventOgreBeingDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventOgreBeingDestroyed
static int tolua_set_EmberOgre__EmberOgre_EventOgreBeingDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventOgreBeingDestroyed'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventOgreBeingDestroyed = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventOgreDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventOgreDestroyed
static int tolua_get_EmberOgre__EmberOgre_EventOgreDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventOgreDestroyed'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventOgreDestroyed,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventOgreDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventOgreDestroyed
static int tolua_set_EmberOgre__EmberOgre_EventOgreDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventOgreDestroyed'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventOgreDestroyed = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventMotionManagerCreated of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventMotionManagerCreated
static int tolua_get_EmberOgre__EmberOgre_EventMotionManagerCreated(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMotionManagerCreated'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventMotionManagerCreated,"sigc::signal<void,EmberOgre::MotionManager&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventMotionManagerCreated of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventMotionManagerCreated
static int tolua_set_EmberOgre__EmberOgre_EventMotionManagerCreated(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMotionManagerCreated'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::MotionManager&>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventMotionManagerCreated = *((sigc::signal<void,EmberOgre::MotionManager&>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventTerrainManagerCreated of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventTerrainManagerCreated
static int tolua_get_EmberOgre__EmberOgre_EventTerrainManagerCreated(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventTerrainManagerCreated'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventTerrainManagerCreated,"sigc::signal<void,EmberOgre::Terrain::TerrainManager&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventTerrainManagerCreated of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventTerrainManagerCreated
static int tolua_set_EmberOgre__EmberOgre_EventTerrainManagerCreated(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventTerrainManagerCreated'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::Terrain::TerrainManager&>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventTerrainManagerCreated = *((sigc::signal<void,EmberOgre::Terrain::TerrainManager&>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventTerrainManagerDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventTerrainManagerDestroyed
static int tolua_get_EmberOgre__EmberOgre_EventTerrainManagerDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventTerrainManagerDestroyed'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventTerrainManagerDestroyed,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventTerrainManagerDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventTerrainManagerDestroyed
static int tolua_set_EmberOgre__EmberOgre_EventTerrainManagerDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventTerrainManagerDestroyed'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventTerrainManagerDestroyed = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventMotionManagerDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventMotionManagerDestroyed
static int tolua_get_EmberOgre__EmberOgre_EventMotionManagerDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMotionManagerDestroyed'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventMotionManagerDestroyed,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventMotionManagerDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventMotionManagerDestroyed
static int tolua_set_EmberOgre__EmberOgre_EventMotionManagerDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMotionManagerDestroyed'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventMotionManagerDestroyed = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventMovementControllerCreated of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventMovementControllerCreated
static int tolua_get_EmberOgre__EmberOgre_EventMovementControllerCreated(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMovementControllerCreated'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventMovementControllerCreated,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventMovementControllerCreated of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventMovementControllerCreated
static int tolua_set_EmberOgre__EmberOgre_EventMovementControllerCreated(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMovementControllerCreated'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventMovementControllerCreated = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventMovementControllerDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventMovementControllerDestroyed
static int tolua_get_EmberOgre__EmberOgre_EventMovementControllerDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMovementControllerDestroyed'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventMovementControllerDestroyed,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventMovementControllerDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventMovementControllerDestroyed
static int tolua_set_EmberOgre__EmberOgre_EventMovementControllerDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMovementControllerDestroyed'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventMovementControllerDestroyed = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventWorldCreated of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventWorldCreated
static int tolua_get_EmberOgre__EmberOgre_EventWorldCreated(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventWorldCreated'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventWorldCreated,"sigc::signal<void,EmberOgre::World&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventWorldCreated of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventWorldCreated
static int tolua_set_EmberOgre__EmberOgre_EventWorldCreated(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventWorldCreated'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,EmberOgre::World&>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventWorldCreated = *((sigc::signal<void,EmberOgre::World&>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventWorldDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__EmberOgre_EventWorldDestroyed
static int tolua_get_EmberOgre__EmberOgre_EventWorldDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventWorldDestroyed'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventWorldDestroyed,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventWorldDestroyed of class  EmberOgre::EmberOgre */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__EmberOgre_EventWorldDestroyed
static int tolua_set_EmberOgre__EmberOgre_EventWorldDestroyed(lua_State* tolua_S)
{
  EmberOgre::EmberOgre* self = (EmberOgre::EmberOgre*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventWorldDestroyed'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventWorldDestroyed = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_EmberOgre_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Camera",0);
   tolua_beginmodule(tolua_S,"Camera");
    tolua_cclass(tolua_S,"MainCamera","EmberOgre::Camera::MainCamera","",NULL);
    tolua_beginmodule(tolua_S,"MainCamera");
     tolua_function(tolua_S,"getCamera",tolua_EmberOgre_EmberOgre_Camera_MainCamera_getCamera00);
     tolua_function(tolua_S,"getOrientation",tolua_EmberOgre_EmberOgre_Camera_MainCamera_getOrientation00);
     tolua_function(tolua_S,"getPosition",tolua_EmberOgre_EmberOgre_Camera_MainCamera_getPosition00);
     tolua_variable(tolua_S,"MovedCamera",tolua_get_EmberOgre__Camera__MainCamera_MovedCamera,tolua_set_EmberOgre__Camera__MainCamera_MovedCamera);
     tolua_function(tolua_S,"setClosestPickingDistance",tolua_EmberOgre_EmberOgre_Camera_MainCamera_setClosestPickingDistance00);
     tolua_function(tolua_S,"getClosestPickingDistance",tolua_EmberOgre_EmberOgre_Camera_MainCamera_getClosestPickingDistance00);
     tolua_function(tolua_S,"enableCompositor",tolua_EmberOgre_EmberOgre_Camera_MainCamera_enableCompositor00);
     tolua_function(tolua_S,"toggleRenderMode",tolua_EmberOgre_EmberOgre_Camera_MainCamera_toggleRenderMode00);
     tolua_function(tolua_S,"takeScreenshot",tolua_EmberOgre_EmberOgre_Camera_MainCamera_takeScreenshot00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"MovementControllerMode","EmberOgre::MovementControllerMode","",NULL);
   tolua_beginmodule(tolua_S,"MovementControllerMode");
    tolua_constant(tolua_S,"MM_WALK",EmberOgre::MovementControllerMode::MM_WALK);
    tolua_constant(tolua_S,"MM_RUN",EmberOgre::MovementControllerMode::MM_RUN);
   tolua_endmodule(tolua_S);
   tolua_cclass(tolua_S,"MovementController","EmberOgre::MovementController","",NULL);
   tolua_beginmodule(tolua_S,"MovementController");
    tolua_variable(tolua_S,"EventMovementModeChanged",tolua_get_EmberOgre__MovementController_EventMovementModeChanged,tolua_set_EmberOgre__MovementController_EventMovementModeChanged);
    tolua_function(tolua_S,"moveToPoint",tolua_EmberOgre_EmberOgre_MovementController_moveToPoint00);
    tolua_function(tolua_S,"teleportTo",tolua_EmberOgre_EmberOgre_MovementController_teleportTo00);
    tolua_function(tolua_S,"getMode",tolua_EmberOgre_EmberOgre_MovementController_getMode00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"Avatar","EmberOgre::Avatar","",NULL);
   tolua_beginmodule(tolua_S,"Avatar");
    tolua_function(tolua_S,"getAvatarSceneNode",tolua_EmberOgre_EmberOgre_Avatar_getAvatarSceneNode00);
    tolua_function(tolua_S,"getEmberEntity",tolua_EmberOgre_EmberOgre_Avatar_getEmberEntity00);
    tolua_function(tolua_S,"setMinIntervalOfRotationChanges",tolua_EmberOgre_EmberOgre_Avatar_setMinIntervalOfRotationChanges00);
    tolua_variable(tolua_S,"EventAddedEntityToInventory",tolua_get_EmberOgre__Avatar_EventAddedEntityToInventory,tolua_set_EmberOgre__Avatar_EventAddedEntityToInventory);
    tolua_variable(tolua_S,"EventRemovedEntityFromInventory",tolua_get_EmberOgre__Avatar_EventRemovedEntityFromInventory,tolua_set_EmberOgre__Avatar_EventRemovedEntityFromInventory);
    tolua_function(tolua_S,"isAdmin",tolua_EmberOgre_EmberOgre_Avatar_isAdmin00);
    tolua_function(tolua_S,"getClientSideAvatarPosition",tolua_EmberOgre_EmberOgre_Avatar_getClientSideAvatarPosition00);
    tolua_function(tolua_S,"getClientSideAvatarOrientation",tolua_EmberOgre_EmberOgre_Avatar_getClientSideAvatarOrientation00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"EmberEntityFactory","EmberOgre::EmberEntityFactory","",NULL);
   tolua_beginmodule(tolua_S,"EmberEntityFactory");
    tolua_function(tolua_S,"getWorld",tolua_EmberOgre_EmberOgre_EmberEntityFactory_getWorld00);
    tolua_function(tolua_S,"dumpAttributesOfEntity",tolua_EmberOgre_EmberOgre_EmberEntityFactory_dumpAttributesOfEntity00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"EmberEntity","EmberOgre::EmberEntity","Eris::Entity",NULL);
   tolua_beginmodule(tolua_S,"EmberEntity");
    tolua_constant(tolua_S,"PM_DEFAULT",EmberOgre::EmberEntity::PM_DEFAULT);
    tolua_constant(tolua_S,"PM_FLOATING",EmberOgre::EmberEntity::PM_FLOATING);
    tolua_constant(tolua_S,"PM_PROJECTILE",EmberOgre::EmberEntity::PM_PROJECTILE);
    tolua_constant(tolua_S,"PM_FIXED",EmberOgre::EmberEntity::PM_FIXED);
    tolua_function(tolua_S,"hasSuggestedResponses",tolua_EmberOgre_EmberOgre_EmberEntity_hasSuggestedResponses00);
    tolua_function(tolua_S,"getSuggestedResponses",tolua_EmberOgre_EmberOgre_EmberEntity_getSuggestedResponses00);
    tolua_function(tolua_S,"getEmberLocation",tolua_EmberOgre_EmberOgre_EmberEntity_getEmberLocation00);
    tolua_function(tolua_S,"isInitialized",tolua_EmberOgre_EmberOgre_EmberEntity_isInitialized00);
    tolua_function(tolua_S,"getPositioningMode",tolua_EmberOgre_EmberOgre_EmberEntity_getPositioningMode00);
    tolua_function(tolua_S,"getDefaultUseOperators",tolua_EmberOgre_EmberOgre_EmberEntity_getDefaultUseOperators00);
    tolua_function(tolua_S,"getActions",tolua_EmberOgre_EmberOgre_EmberEntity_getActions00);
    tolua_function(tolua_S,"setVisualize",tolua_EmberOgre_EmberOgre_EmberEntity_setVisualize00);
    tolua_function(tolua_S,"getVisualize",tolua_EmberOgre_EmberOgre_EmberEntity_getVisualize00);
    tolua_function(tolua_S,"dumpAttributes",tolua_EmberOgre_EmberOgre_EmberEntity_dumpAttributes00);
    tolua_function(tolua_S,"getAttachedEntity",tolua_EmberOgre_EmberOgre_EmberEntity_getAttachedEntity00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"WorldEmberEntity","EmberOgre::WorldEmberEntity","EmberOgre::EmberEntity",NULL);
   tolua_beginmodule(tolua_S,"WorldEmberEntity");
    tolua_function(tolua_S,"getEnvironment",tolua_EmberOgre_EmberOgre_WorldEmberEntity_getEnvironment00);
    tolua_function(tolua_S,"getFoliage",tolua_EmberOgre_EmberOgre_WorldEmberEntity_getFoliage00);
    tolua_function(tolua_S,"getTerrainManager",tolua_EmberOgre_EmberOgre_WorldEmberEntity_getTerrainManager00);
    tolua_variable(tolua_S,"EventFoliageCreated",tolua_get_EmberOgre__WorldEmberEntity_EventFoliageCreated,tolua_set_EmberOgre__WorldEmberEntity_EventFoliageCreated);
    tolua_variable(tolua_S,"EventEnvironmentCreated",tolua_get_EmberOgre__WorldEmberEntity_EventEnvironmentCreated,tolua_set_EmberOgre__WorldEmberEntity_EventEnvironmentCreated);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"IGraphicalRepresentation","EmberOgre::IGraphicalRepresentation","",NULL);
   tolua_beginmodule(tolua_S,"IGraphicalRepresentation");
    tolua_function(tolua_S,"getType",tolua_EmberOgre_EmberOgre_IGraphicalRepresentation_getType00);
    tolua_function(tolua_S,"setVisualize",tolua_EmberOgre_EmberOgre_IGraphicalRepresentation_setVisualize00);
    tolua_function(tolua_S,"getVisualize",tolua_EmberOgre_EmberOgre_IGraphicalRepresentation_getVisualize00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Environment",0);
   tolua_beginmodule(tolua_S,"Environment");
    tolua_cclass(tolua_S,"ISun","EmberOgre::Environment::ISun","",NULL);
    tolua_beginmodule(tolua_S,"ISun");
     tolua_function(tolua_S,"setAmbientLight",tolua_EmberOgre_EmberOgre_Environment_ISun_setAmbientLight00);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"ISky","EmberOgre::Environment::ISky","",NULL);
    tolua_beginmodule(tolua_S,"ISky");
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"IFog","EmberOgre::Environment::IFog","",NULL);
    tolua_beginmodule(tolua_S,"IFog");
     tolua_function(tolua_S,"setDensity",tolua_EmberOgre_EmberOgre_Environment_IFog_setDensity00);
     tolua_function(tolua_S,"getDensity",tolua_EmberOgre_EmberOgre_Environment_IFog_getDensity00);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"IWater","EmberOgre::Environment::IWater","",NULL);
    tolua_beginmodule(tolua_S,"IWater");
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"Environment","EmberOgre::Environment::Environment","",NULL);
    tolua_beginmodule(tolua_S,"Environment");
     tolua_function(tolua_S,"getSun",tolua_EmberOgre_EmberOgre_Environment_Environment_getSun00);
     tolua_function(tolua_S,"getSky",tolua_EmberOgre_EmberOgre_Environment_Environment_getSky00);
     tolua_function(tolua_S,"getFog",tolua_EmberOgre_EmberOgre_Environment_Environment_getFog00);
     tolua_function(tolua_S,"getWater",tolua_EmberOgre_EmberOgre_Environment_Environment_getWater00);
     tolua_function(tolua_S,"setTime",tolua_EmberOgre_EmberOgre_Environment_Environment_setTime00);
     tolua_function(tolua_S,"setTime",tolua_EmberOgre_EmberOgre_Environment_Environment_setTime01);
     tolua_function(tolua_S,"setAmbientLight",tolua_EmberOgre_EmberOgre_Environment_Environment_setAmbientLight00);
     tolua_variable(tolua_S,"EventUpdatedAmbientLight",tolua_get_EmberOgre__Environment__Environment_EventUpdatedAmbientLight,NULL);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"GUIManager","EmberOgre::GUIManager","",NULL);
   tolua_beginmodule(tolua_S,"GUIManager");
    tolua_function(tolua_S,"getSingleton",tolua_EmberOgre_EmberOgre_GUIManager_getSingleton00);
    tolua_variable(tolua_S,"AppendIGChatLine",tolua_get_EmberOgre__GUIManager_AppendIGChatLine,NULL);
    tolua_variable(tolua_S,"AppendOOGChatLine",tolua_get_EmberOgre__GUIManager_AppendOOGChatLine,NULL);
    tolua_variable(tolua_S,"AppendAvatarImaginary",tolua_get_EmberOgre__GUIManager_AppendAvatarImaginary,NULL);
    tolua_variable(tolua_S,"EventEntityAction",tolua_get_EmberOgre__GUIManager_EventEntityAction,NULL);
    tolua_variable(tolua_S,"EventFrameStarted",tolua_get_EmberOgre__GUIManager_EventFrameStarted,tolua_set_EmberOgre__GUIManager_EventFrameStarted);
    tolua_function(tolua_S,"removeWidget",tolua_EmberOgre_EmberOgre_GUIManager_removeWidget00);
    tolua_function(tolua_S,"addWidget",tolua_EmberOgre_EmberOgre_GUIManager_addWidget00);
    tolua_function(tolua_S,"EmitEntityAction",tolua_EmberOgre_EmberOgre_GUIManager_EmitEntityAction00);
    tolua_function(tolua_S,"getMainSheet",tolua_EmberOgre_EmberOgre_GUIManager_getMainSheet00);
    tolua_function(tolua_S,"isInGUIMode",tolua_EmberOgre_EmberOgre_GUIManager_isInGUIMode00);
    tolua_function(tolua_S,"isInMovementKeysMode",tolua_EmberOgre_EmberOgre_GUIManager_isInMovementKeysMode00);
    tolua_function(tolua_S,"createWindow",tolua_EmberOgre_EmberOgre_GUIManager_createWindow00);
    tolua_function(tolua_S,"createWindow",tolua_EmberOgre_EmberOgre_GUIManager_createWindow01);
    tolua_function(tolua_S,"createWidget",tolua_EmberOgre_EmberOgre_GUIManager_createWidget00);
    tolua_function(tolua_S,"createWidget",tolua_EmberOgre_EmberOgre_GUIManager_createWidget01);
    tolua_function(tolua_S,"destroyWidget",tolua_EmberOgre_EmberOgre_GUIManager_destroyWidget00);
    tolua_function(tolua_S,"getDefaultScheme",tolua_EmberOgre_EmberOgre_GUIManager_getDefaultScheme00);
    tolua_function(tolua_S,"getIconManager",tolua_EmberOgre_EmberOgre_GUIManager_getIconManager00);
    tolua_function(tolua_S,"getEntityIconManager",tolua_EmberOgre_EmberOgre_GUIManager_getEntityIconManager00);
    tolua_function(tolua_S,"getActionBarIconManager",tolua_EmberOgre_EmberOgre_GUIManager_getActionBarIconManager00);
    tolua_function(tolua_S,"getEntityTooltip",tolua_EmberOgre_EmberOgre_GUIManager_getEntityTooltip00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Terrain",0);
   tolua_beginmodule(tolua_S,"Terrain");
    tolua_cclass(tolua_S,"TerrainShader","EmberOgre::Terrain::TerrainShader","",NULL);
    tolua_beginmodule(tolua_S,"TerrainShader");
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"TerrainPage","EmberOgre::Terrain::TerrainPage","",NULL);
    tolua_beginmodule(tolua_S,"TerrainPage");
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"TerrainArea","EmberOgre::Terrain::TerrainArea","",tolua_collect_EmberOgre__Terrain__TerrainArea);
    #else
    tolua_cclass(tolua_S,"TerrainArea","EmberOgre::Terrain::TerrainArea","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"TerrainArea");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_new00_local);
     tolua_function(tolua_S,"init",tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_init00);
     tolua_function(tolua_S,"getArea",tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_getArea00);
     tolua_function(tolua_S,"setArea",tolua_EmberOgre_EmberOgre_Terrain_TerrainArea_setArea00);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"TerrainMod","EmberOgre::Terrain::TerrainMod","",NULL);
    tolua_beginmodule(tolua_S,"TerrainMod");
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"TerrainLayerDefinition","EmberOgre::Terrain::TerrainLayerDefinition","",NULL);
    tolua_beginmodule(tolua_S,"TerrainLayerDefinition");
     tolua_function(tolua_S,"getName",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getName00);
     tolua_function(tolua_S,"getAreaId",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getAreaId00);
     tolua_function(tolua_S,"getDiffuseTextureName",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getDiffuseTextureName00);
     tolua_function(tolua_S,"getNormalMapTextureName",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getNormalMapTextureName00);
     tolua_function(tolua_S,"getShaderName",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getShaderName00);
     tolua_function(tolua_S,"getTileSize",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinition_getTileSize00);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"TerrainPageSurfaceLayer","EmberOgre::Terrain::TerrainPageSurfaceLayer","",NULL);
    tolua_beginmodule(tolua_S,"TerrainPageSurfaceLayer");
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"ISceneManagerAdapter","EmberOgre::Terrain::ISceneManagerAdapter","",NULL);
    tolua_beginmodule(tolua_S,"ISceneManagerAdapter");
     tolua_function(tolua_S,"getDebugInfo",tolua_EmberOgre_EmberOgre_Terrain_ISceneManagerAdapter_getDebugInfo00);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"TerrainManager","EmberOgre::Terrain::TerrainManager","",NULL);
    tolua_beginmodule(tolua_S,"TerrainManager");
     tolua_function(tolua_S,"getMax",tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getMax00);
     tolua_function(tolua_S,"getMin",tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getMin00);
     tolua_function(tolua_S,"getPageMetersSize",tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getPageMetersSize00);
     tolua_function(tolua_S,"updateShadows",tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_updateShadows00);
     tolua_variable(tolua_S,"UpdateShadows",tolua_get_EmberOgre__Terrain__TerrainManager_UpdateShadows,NULL);
     tolua_variable(tolua_S,"EventTerrainPageGeometryUpdated",tolua_get_EmberOgre__Terrain__TerrainManager_EventTerrainPageGeometryUpdated,tolua_set_EmberOgre__Terrain__TerrainManager_EventTerrainPageGeometryUpdated);
     tolua_function(tolua_S,"getAdapter",tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getAdapter00);
     tolua_function(tolua_S,"getScene",tolua_EmberOgre_EmberOgre_Terrain_TerrainManager_getScene00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Terrain",0);
   tolua_beginmodule(tolua_S,"Terrain");
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Mercator",0);
  tolua_beginmodule(tolua_S,"Mercator");
   tolua_cclass(tolua_S,"Area","Mercator::Area","",NULL);
   tolua_beginmodule(tolua_S,"Area");
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Terrain",0);
   tolua_beginmodule(tolua_S,"Terrain");
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Terrain",0);
   tolua_beginmodule(tolua_S,"Terrain");
    tolua_cclass(tolua_S,"BasePointUserObject","EmberOgre::Terrain::BasePointUserObject","",NULL);
    tolua_beginmodule(tolua_S,"BasePointUserObject");
     tolua_function(tolua_S,"getBasePoint",tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_getBasePoint00);
     tolua_function(tolua_S,"getBasePointMarkerNode",tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_getBasePointMarkerNode00);
     tolua_function(tolua_S,"getPosition",tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_getPosition00);
     tolua_function(tolua_S,"getHeight",tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_getHeight00);
     tolua_function(tolua_S,"translate",tolua_EmberOgre_EmberOgre_Terrain_BasePointUserObject_translate00);
     tolua_variable(tolua_S,"EventUpdatedPosition",tolua_get_EmberOgre__Terrain__BasePointUserObject_EventUpdatedPosition,tolua_set_EmberOgre__Terrain__BasePointUserObject_EventUpdatedPosition);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"TerrainEditAction","EmberOgre::Terrain::TerrainEditAction","",NULL);
    tolua_beginmodule(tolua_S,"TerrainEditAction");
     tolua_function(tolua_S,"getMovements",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditAction_getMovements00);
     tolua_function(tolua_S,"getMovements",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditAction_getMovements01);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"TerrainEditBasePointMovement","EmberOgre::Terrain::TerrainEditBasePointMovement","",NULL);
    tolua_beginmodule(tolua_S,"TerrainEditBasePointMovement");
     tolua_function(tolua_S,"getVerticalMovement",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditBasePointMovement_getVerticalMovement00);
     tolua_function(tolua_S,"getPosition",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditBasePointMovement_getPosition00);
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"TerrainEditor","EmberOgre::Terrain::TerrainEditor","",tolua_collect_EmberOgre__Terrain__TerrainEditor);
    #else
    tolua_cclass(tolua_S,"TerrainEditor","EmberOgre::Terrain::TerrainEditor","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"TerrainEditor");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_delete00);
     tolua_function(tolua_S,"showOverlay",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_showOverlay00);
     tolua_function(tolua_S,"hideOverlay",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_hideOverlay00);
     tolua_function(tolua_S,"isOverlayShown",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_isOverlayShown00);
     tolua_variable(tolua_S,"EventOverlayCreated",tolua_get_EmberOgre__Terrain__TerrainEditor_EventOverlayCreated,tolua_set_EmberOgre__Terrain__TerrainEditor_EventOverlayCreated);
     tolua_variable(tolua_S,"EventOverlayDestroyed",tolua_get_EmberOgre__Terrain__TerrainEditor_EventOverlayDestroyed,tolua_set_EmberOgre__Terrain__TerrainEditor_EventOverlayDestroyed);
     tolua_function(tolua_S,"getRadius",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_getRadius00);
     tolua_function(tolua_S,"setRadius",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_setRadius00);
     tolua_function(tolua_S,"getFalloff",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_getFalloff00);
     tolua_function(tolua_S,"setFalloff",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditor_setFalloff00);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"TerrainEditorOverlay","EmberOgre::Terrain::TerrainEditorOverlay","",NULL);
    tolua_beginmodule(tolua_S,"TerrainEditorOverlay");
     tolua_function(tolua_S,"commitAction",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_commitAction00);
     tolua_function(tolua_S,"getCurrentBasePointUserObject",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_getCurrentBasePointUserObject00);
     tolua_function(tolua_S,"sendChangesToServer",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_sendChangesToServer00);
     tolua_function(tolua_S,"createAction",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_createAction00);
     tolua_function(tolua_S,"undoLastAction",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_undoLastAction00);
     tolua_function(tolua_S,"redoAction",tolua_EmberOgre_EmberOgre_Terrain_TerrainEditorOverlay_redoAction00);
     tolua_variable(tolua_S,"EventPickedBasePoint",tolua_get_EmberOgre__Terrain__TerrainEditorOverlay_EventPickedBasePoint,tolua_set_EmberOgre__Terrain__TerrainEditorOverlay_EventPickedBasePoint);
     tolua_variable(tolua_S,"EventActionCreated",tolua_get_EmberOgre__Terrain__TerrainEditorOverlay_EventActionCreated,NULL);
     tolua_variable(tolua_S,"EventSelectedBasePointUpdatedPosition",tolua_get_EmberOgre__Terrain__TerrainEditorOverlay_EventSelectedBasePointUpdatedPosition,tolua_set_EmberOgre__Terrain__TerrainEditorOverlay_EventSelectedBasePointUpdatedPosition);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"IAnimated","EmberOgre::IAnimated","",NULL);
   tolua_beginmodule(tolua_S,"IAnimated");
    tolua_function(tolua_S,"updateAnimation",tolua_EmberOgre_EmberOgre_IAnimated_updateAnimation00);
   tolua_endmodule(tolua_S);
   tolua_cclass(tolua_S,"MotionManager","EmberOgre::MotionManager","",NULL);
   tolua_beginmodule(tolua_S,"MotionManager");
    tolua_cclass(tolua_S,"MotionManagerInfo","EmberOgre::MotionManager::MotionManagerInfo","",NULL);
    tolua_beginmodule(tolua_S,"MotionManagerInfo");
     tolua_variable(tolua_S,"AnimatedEntities",tolua_get_EmberOgre__MotionManager__MotionManagerInfo_AnimatedEntities,tolua_set_EmberOgre__MotionManager__MotionManagerInfo_AnimatedEntities);
     tolua_variable(tolua_S,"MovingEntities",tolua_get_EmberOgre__MotionManager__MotionManagerInfo_MovingEntities,tolua_set_EmberOgre__MotionManager__MotionManagerInfo_MovingEntities);
    tolua_endmodule(tolua_S);
    tolua_function(tolua_S,"getSingleton",tolua_EmberOgre_EmberOgre_MotionManager_getSingleton00);
    tolua_function(tolua_S,"getInfo",tolua_EmberOgre_EmberOgre_MotionManager_getInfo00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_cclass(tolua_S,"Widget","EmberOgre::Gui::Widget","",NULL);
    tolua_beginmodule(tolua_S,"Widget");
     tolua_function(tolua_S,"show",tolua_EmberOgre_EmberOgre_Gui_Widget_show00);
     tolua_function(tolua_S,"hide",tolua_EmberOgre_EmberOgre_Gui_Widget_hide00);
     tolua_function(tolua_S,"isVisible",tolua_EmberOgre_EmberOgre_Gui_Widget_isVisible00);
     tolua_function(tolua_S,"isActive",tolua_EmberOgre_EmberOgre_Gui_Widget_isActive00);
     tolua_function(tolua_S,"getWindow",tolua_EmberOgre_EmberOgre_Gui_Widget_getWindow00);
     tolua_function(tolua_S,"enableCloseButton",tolua_EmberOgre_EmberOgre_Gui_Widget_enableCloseButton00);
     tolua_function(tolua_S,"registerConsoleVisibilityToggleCommand",tolua_EmberOgre_EmberOgre_Gui_Widget_registerConsoleVisibilityToggleCommand00);
     tolua_function(tolua_S,"getMainSheet",tolua_EmberOgre_EmberOgre_Gui_Widget_getMainSheet00);
     tolua_function(tolua_S,"getMainWindow",tolua_EmberOgre_EmberOgre_Gui_Widget_getMainWindow00);
     tolua_function(tolua_S,"createWindow",tolua_EmberOgre_EmberOgre_Gui_Widget_createWindow00);
     tolua_function(tolua_S,"createWindow",tolua_EmberOgre_EmberOgre_Gui_Widget_createWindow01);
     tolua_function(tolua_S,"loadMainSheet",tolua_EmberOgre_EmberOgre_Gui_Widget_loadMainSheet00);
     tolua_function(tolua_S,"getPrefix",tolua_EmberOgre_EmberOgre_Gui_Widget_getPrefix00);
     tolua_function(tolua_S,"getIsActiveWindowOpaque",tolua_EmberOgre_EmberOgre_Gui_Widget_getIsActiveWindowOpaque00);
     tolua_function(tolua_S,"setIsActiveWindowOpaque",tolua_EmberOgre_EmberOgre_Gui_Widget_setIsActiveWindowOpaque00);
     tolua_function(tolua_S,"getDefaultScheme",tolua_EmberOgre_EmberOgre_Gui_Widget_getDefaultScheme00);
     tolua_function(tolua_S,"addTabbableWindow",tolua_EmberOgre_EmberOgre_Gui_Widget_addTabbableWindow00);
     tolua_function(tolua_S,"closeTabGroup",tolua_EmberOgre_EmberOgre_Gui_Widget_closeTabGroup00);
     tolua_variable(tolua_S,"EventFrameStarted",tolua_get_EmberOgre__Gui__Widget_EventFrameStarted,tolua_set_EmberOgre__Gui__Widget_EventFrameStarted);
     tolua_variable(tolua_S,"EventFirstTimeShown",tolua_get_EmberOgre__Gui__Widget_EventFirstTimeShown,tolua_set_EmberOgre__Gui__Widget_EventFirstTimeShown);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"IconBase","EmberOgre::Gui::IconBase","",tolua_collect_EmberOgre__Gui__IconBase);
    #else
    tolua_cclass(tolua_S,"IconBase","EmberOgre::Gui::IconBase","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"IconBase");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_IconBase_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_IconBase_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_IconBase_new00_local);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_IconBase_new01);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_IconBase_new01_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_IconBase_new01_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_IconBase_delete00);
     tolua_function(tolua_S,"getContainer",tolua_EmberOgre_EmberOgre_Gui_IconBase_getContainer00);
     tolua_function(tolua_S,"getButton",tolua_EmberOgre_EmberOgre_Gui_IconBase_getButton00);
     tolua_function(tolua_S,"setForeground",tolua_EmberOgre_EmberOgre_Gui_IconBase_setForeground00);
     tolua_function(tolua_S,"loadImageFromImageset",tolua_EmberOgre_EmberOgre_Gui_IconBase_loadImageFromImageset00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"IconBar","EmberOgre::Gui::IconBar","",tolua_collect_EmberOgre__Gui__IconBar);
    #else
    tolua_cclass(tolua_S,"IconBar","EmberOgre::Gui::IconBar","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"IconBar");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_IconBar_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_IconBar_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_IconBar_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_IconBar_delete00);
     tolua_function(tolua_S,"addIcon",tolua_EmberOgre_EmberOgre_Gui_IconBar_addIcon00);
     tolua_function(tolua_S,"removeIcon",tolua_EmberOgre_EmberOgre_Gui_IconBar_removeIcon00);
     tolua_function(tolua_S,"getWindow",tolua_EmberOgre_EmberOgre_Gui_IconBar_getWindow00);
     tolua_function(tolua_S,"setIconPadding",tolua_EmberOgre_EmberOgre_Gui_IconBar_setIconPadding00);
     tolua_function(tolua_S,"getAbsoluteHeight",tolua_EmberOgre_EmberOgre_Gui_IconBar_getAbsoluteHeight00);
     tolua_function(tolua_S,"getAbsoluteWidth",tolua_EmberOgre_EmberOgre_Gui_IconBar_getAbsoluteWidth00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"EntityEditor","EmberOgre::Gui::EntityEditor","",tolua_collect_EmberOgre__Gui__EntityEditor);
    #else
    tolua_cclass(tolua_S,"EntityEditor","EmberOgre::Gui::EntityEditor","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"EntityEditor");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_EntityEditor_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_EntityEditor_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_EntityEditor_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_EntityEditor_delete00);
     tolua_function(tolua_S,"submitChanges",tolua_EmberOgre_EmberOgre_Gui_EntityEditor_submitChanges00);
     tolua_function(tolua_S,"createMapElement",tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createMapElement00);
     tolua_function(tolua_S,"createListElement",tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createListElement00);
     tolua_function(tolua_S,"createStringElement",tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createStringElement00);
     tolua_function(tolua_S,"createIntElement",tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createIntElement00);
     tolua_function(tolua_S,"createFloatElement",tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createFloatElement00);
     tolua_function(tolua_S,"createPosition2dElement",tolua_EmberOgre_EmberOgre_Gui_EntityEditor_createPosition2dElement00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"StackableContainer","EmberOgre::Gui::StackableContainer","",tolua_collect_EmberOgre__Gui__StackableContainer);
    #else
    tolua_cclass(tolua_S,"StackableContainer","EmberOgre::Gui::StackableContainer","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"StackableContainer");
     tolua_constant(tolua_S,"Horizontal",EmberOgre::Gui::StackableContainer::Horizontal);
     tolua_constant(tolua_S,"Vertical",EmberOgre::Gui::StackableContainer::Vertical);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_delete00);
     tolua_function(tolua_S,"setInnerContainerWindow",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_setInnerContainerWindow00);
     tolua_function(tolua_S,"getWindow",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getWindow00);
     tolua_function(tolua_S,"setPadding",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_setPadding00);
     tolua_function(tolua_S,"getPadding",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getPadding00);
     tolua_function(tolua_S,"getAbsoluteHeight",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getAbsoluteHeight00);
     tolua_function(tolua_S,"getAbsoluteWidth",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getAbsoluteWidth00);
     tolua_function(tolua_S,"setFlowDirection",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_setFlowDirection00);
     tolua_function(tolua_S,"getFlowDirection",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_getFlowDirection00);
     tolua_function(tolua_S,"repositionWindows",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_repositionWindows00);
     tolua_function(tolua_S,"disconnect",tolua_EmberOgre_EmberOgre_Gui_StackableContainer_disconnect00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"ConsoleAdapter","EmberOgre::Gui::ConsoleAdapter","",tolua_collect_EmberOgre__Gui__ConsoleAdapter);
    #else
    tolua_cclass(tolua_S,"ConsoleAdapter","EmberOgre::Gui::ConsoleAdapter","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"ConsoleAdapter");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_ConsoleAdapter_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_ConsoleAdapter_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_ConsoleAdapter_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_ConsoleAdapter_delete00);
     tolua_variable(tolua_S,"EventCommandExecuted",tolua_get_EmberOgre__Gui__ConsoleAdapter_EventCommandExecuted,NULL);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_cclass(tolua_S,"ColouredListItem","EmberOgre::Gui::ColouredListItem","CEGUI::ListboxTextItem",NULL);
    tolua_beginmodule(tolua_S,"ColouredListItem");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_ColouredListItem_new00);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_ColouredListItem_new01);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_ColouredListItem_new02);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"ColouredTreeItem","EmberOgre::Gui::ColouredTreeItem","CEGUI::TreeItem",NULL);
    tolua_beginmodule(tolua_S,"ColouredTreeItem");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_ColouredTreeItem_new00);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_ColouredTreeItem_new01);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_ColouredTreeItem_new02);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"TexturePair","EmberOgre::Gui::TexturePair","",tolua_collect_EmberOgre__Gui__TexturePair);
    #else
    tolua_cclass(tolua_S,"TexturePair","EmberOgre::Gui::TexturePair","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"TexturePair");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_TexturePair_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_TexturePair_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_TexturePair_new00_local);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_TexturePair_new01);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_TexturePair_new01_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_TexturePair_new01_local);
     tolua_function(tolua_S,"getOgreTexture",tolua_EmberOgre_EmberOgre_Gui_TexturePair_getOgreTexture00);
     tolua_function(tolua_S,"getTextureImage",tolua_EmberOgre_EmberOgre_Gui_TexturePair_getTextureImage00);
     tolua_function(tolua_S,"getTextureImageset",tolua_EmberOgre_EmberOgre_Gui_TexturePair_getTextureImageset00);
     tolua_function(tolua_S,"hasData",tolua_EmberOgre_EmberOgre_Gui_TexturePair_hasData00);
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"AssetsManager","EmberOgre::Gui::AssetsManager","",tolua_collect_EmberOgre__Gui__AssetsManager);
    #else
    tolua_cclass(tolua_S,"AssetsManager","EmberOgre::Gui::AssetsManager","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"AssetsManager");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_AssetsManager_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_AssetsManager_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_AssetsManager_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_AssetsManager_delete00);
     tolua_function(tolua_S,"showTexture",tolua_EmberOgre_EmberOgre_Gui_AssetsManager_showTexture00);
     tolua_function(tolua_S,"createTextureImage",tolua_EmberOgre_EmberOgre_Gui_AssetsManager_createTextureImage00);
     tolua_function(tolua_S,"materialAsText",tolua_EmberOgre_EmberOgre_Gui_AssetsManager_materialAsText00);
     tolua_function(tolua_S,"resolveResourceNameFromFilePath",tolua_EmberOgre_EmberOgre_Gui_AssetsManager_resolveResourceNameFromFilePath00);
     tolua_function(tolua_S,"resolveFilePathForMesh",tolua_EmberOgre_EmberOgre_Gui_AssetsManager_resolveFilePathForMesh00);
     tolua_function(tolua_S,"exportMesh",tolua_EmberOgre_EmberOgre_Gui_AssetsManager_exportMesh00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_cclass(tolua_S,"AtlasHelper","EmberOgre::Gui::AtlasHelper","",NULL);
    tolua_beginmodule(tolua_S,"AtlasHelper");
     tolua_function(tolua_S,"serialize",tolua_EmberOgre_EmberOgre_Gui_AtlasHelper_serialize00);
     tolua_function(tolua_S,"serialize",tolua_EmberOgre_EmberOgre_Gui_AtlasHelper_serialize01);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_cclass(tolua_S,"ICompassImpl","EmberOgre::Gui::ICompassImpl","",NULL);
    tolua_beginmodule(tolua_S,"ICompassImpl");
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"Compass","EmberOgre::Gui::Compass","",tolua_collect_EmberOgre__Gui__Compass);
    #else
    tolua_cclass(tolua_S,"Compass","EmberOgre::Gui::Compass","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"Compass");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_Compass_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_Compass_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_Compass_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_Compass_delete00);
     tolua_function(tolua_S,"getMap",tolua_EmberOgre_EmberOgre_Gui_Compass_getMap00);
     tolua_function(tolua_S,"reposition",tolua_EmberOgre_EmberOgre_Gui_Compass_reposition00);
     tolua_function(tolua_S,"rotate",tolua_EmberOgre_EmberOgre_Gui_Compass_rotate00);
     tolua_function(tolua_S,"rotate",tolua_EmberOgre_EmberOgre_Gui_Compass_rotate01);
     tolua_function(tolua_S,"refresh",tolua_EmberOgre_EmberOgre_Gui_Compass_refresh00);
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"CEGUICompassImpl","EmberOgre::Gui::CEGUICompassImpl","EmberOgre::Gui::ICompassImpl",tolua_collect_EmberOgre__Gui__CEGUICompassImpl);
    #else
    tolua_cclass(tolua_S,"CEGUICompassImpl","EmberOgre::Gui::CEGUICompassImpl","EmberOgre::Gui::ICompassImpl",NULL);
    #endif
    tolua_beginmodule(tolua_S,"CEGUICompassImpl");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_delete00);
     tolua_function(tolua_S,"getViewImage",tolua_EmberOgre_EmberOgre_Gui_CEGUICompassImpl_getViewImage00);
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"OverlayCompassImpl","EmberOgre::Gui::OverlayCompassImpl","EmberOgre::Gui::ICompassImpl",tolua_collect_EmberOgre__Gui__OverlayCompassImpl);
    #else
    tolua_cclass(tolua_S,"OverlayCompassImpl","EmberOgre::Gui::OverlayCompassImpl","EmberOgre::Gui::ICompassImpl",NULL);
    #endif
    tolua_beginmodule(tolua_S,"OverlayCompassImpl");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_OverlayCompassImpl_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_OverlayCompassImpl_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_OverlayCompassImpl_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_OverlayCompassImpl_delete00);
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"RenderedCompassImpl","EmberOgre::Gui::RenderedCompassImpl","EmberOgre::Gui::ICompassImpl",tolua_collect_EmberOgre__Gui__RenderedCompassImpl);
    #else
    tolua_cclass(tolua_S,"RenderedCompassImpl","EmberOgre::Gui::RenderedCompassImpl","EmberOgre::Gui::ICompassImpl",NULL);
    #endif
    tolua_beginmodule(tolua_S,"RenderedCompassImpl");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new00_local);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new01);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new01_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new01_local);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new02);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new02_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_new02_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_delete00);
     tolua_function(tolua_S,"getTexture",tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_getTexture00);
     tolua_function(tolua_S,"getPointerTexture",tolua_EmberOgre_EmberOgre_Gui_RenderedCompassImpl_getPointerTexture00);
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"CompassCameraAnchor","EmberOgre::Gui::CompassCameraAnchor","",tolua_collect_EmberOgre__Gui__CompassCameraAnchor);
    #else
    tolua_cclass(tolua_S,"CompassCameraAnchor","EmberOgre::Gui::CompassCameraAnchor","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"CompassCameraAnchor");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_CompassCameraAnchor_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_CompassCameraAnchor_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_CompassCameraAnchor_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_CompassCameraAnchor_delete00);
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"CompassSceneNodeAnchor","EmberOgre::Gui::CompassSceneNodeAnchor","",tolua_collect_EmberOgre__Gui__CompassSceneNodeAnchor);
    #else
    tolua_cclass(tolua_S,"CompassSceneNodeAnchor","EmberOgre::Gui::CompassSceneNodeAnchor","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"CompassSceneNodeAnchor");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_CompassSceneNodeAnchor_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_CompassSceneNodeAnchor_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_CompassSceneNodeAnchor_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_CompassSceneNodeAnchor_delete00);
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"CompassThirdPersonCameraAnchor","EmberOgre::Gui::CompassThirdPersonCameraAnchor","",tolua_collect_EmberOgre__Gui__CompassThirdPersonCameraAnchor);
    #else
    tolua_cclass(tolua_S,"CompassThirdPersonCameraAnchor","EmberOgre::Gui::CompassThirdPersonCameraAnchor","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"CompassThirdPersonCameraAnchor");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_CompassThirdPersonCameraAnchor_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_CompassThirdPersonCameraAnchor_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_CompassThirdPersonCameraAnchor_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_CompassThirdPersonCameraAnchor_delete00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Eris",0);
     tolua_beginmodule(tolua_S,"Eris");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"TypeTreeAdapter","EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter","virtual sigc::trackable",tolua_collect_EmberOgre__Gui__Adapters__Eris__TypeTreeAdapter);
      #else
      tolua_cclass(tolua_S,"TypeTreeAdapter","EmberOgre::Gui::Adapters::Eris::TypeTreeAdapter","virtual sigc::trackable",NULL);
      #endif
      tolua_beginmodule(tolua_S,"TypeTreeAdapter");
       tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_delete00);
       tolua_function(tolua_S,"initialize",tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_initialize00);
       tolua_function(tolua_S,"getSelectedTypeInfo",tolua_EmberOgre_EmberOgre_Gui_Adapters_Eris_TypeTreeAdapter_getSelectedTypeInfo00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Ogre",0);
     tolua_beginmodule(tolua_S,"Ogre");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"ResourceListAdapter","EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter","",tolua_collect_EmberOgre__Gui__Adapters__Ogre__ResourceListAdapter);
      #else
      tolua_cclass(tolua_S,"ResourceListAdapter","EmberOgre::Gui::Adapters::Ogre::ResourceListAdapter","",NULL);
      #endif
      tolua_beginmodule(tolua_S,"ResourceListAdapter");
       tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_delete00);
       tolua_function(tolua_S,"update",tolua_EmberOgre_EmberOgre_Gui_Adapters_Ogre_ResourceListAdapter_update00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Icons",0);
    tolua_beginmodule(tolua_S,"Icons");
     tolua_cclass(tolua_S,"Icon","EmberOgre::Gui::Icons::Icon","",NULL);
     tolua_beginmodule(tolua_S,"Icon");
      tolua_function(tolua_S,"getImage",tolua_EmberOgre_EmberOgre_Gui_Icons_Icon_getImage00);
      tolua_function(tolua_S,"getImage",tolua_EmberOgre_EmberOgre_Gui_Icons_Icon_getImage01);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Icons",0);
    tolua_beginmodule(tolua_S,"Icons");
     #ifdef __cplusplus
     tolua_cclass(tolua_S,"IconManager","EmberOgre::Gui::Icons::IconManager","",tolua_collect_EmberOgre__Gui__Icons__IconManager);
     #else
     tolua_cclass(tolua_S,"IconManager","EmberOgre::Gui::Icons::IconManager","",NULL);
     #endif
     tolua_beginmodule(tolua_S,"IconManager");
      tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_new00);
      tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_new00_local);
      tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_new00_local);
      tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_delete00);
      tolua_function(tolua_S,"getIcon",tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_getIcon00);
      tolua_function(tolua_S,"getIcon",tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_getIcon01);
      tolua_function(tolua_S,"render",tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_render00);
      tolua_function(tolua_S,"render",tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_render01);
      tolua_function(tolua_S,"render",tolua_EmberOgre_EmberOgre_Gui_Icons_IconManager_render02);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_cclass(tolua_S,"EntityIconSlot","EmberOgre::Gui::EntityIconSlot","EmberOgre::Gui::EntityIconDragDropTarget",NULL);
    tolua_beginmodule(tolua_S,"EntityIconSlot");
     tolua_function(tolua_S,"addEntityIcon",tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_addEntityIcon00);
     tolua_function(tolua_S,"removeEntityIcon",tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_removeEntityIcon00);
     tolua_function(tolua_S,"getEntityIcon",tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_getEntityIcon00);
     tolua_function(tolua_S,"getWindow",tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_getWindow00);
     tolua_function(tolua_S,"notifyIconDraggedOff",tolua_EmberOgre_EmberOgre_Gui_EntityIconSlot_notifyIconDraggedOff00);
     tolua_variable(tolua_S,"EventIconDraggedOff",tolua_get_EmberOgre__Gui__EntityIconSlot_EventIconDraggedOff,tolua_set_EmberOgre__Gui__EntityIconSlot_EventIconDraggedOff);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_cclass(tolua_S,"EntityIcon","EmberOgre::Gui::EntityIcon","EmberOgre::Gui::EntityIconDragDropTarget",NULL);
    tolua_beginmodule(tolua_S,"EntityIcon");
     tolua_function(tolua_S,"getImage",tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getImage00);
     tolua_function(tolua_S,"getDragContainer",tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getDragContainer00);
     tolua_function(tolua_S,"getIcon",tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getIcon00);
     tolua_function(tolua_S,"setSlot",tolua_EmberOgre_EmberOgre_Gui_EntityIcon_setSlot00);
     tolua_function(tolua_S,"getSlot",tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getSlot00);
     tolua_function(tolua_S,"setTooltipText",tolua_EmberOgre_EmberOgre_Gui_EntityIcon_setTooltipText00);
     tolua_function(tolua_S,"getEntity",tolua_EmberOgre_EmberOgre_Gui_EntityIcon_getEntity00);
     tolua_function(tolua_S,".eq",tolua_EmberOgre_EmberOgre_Gui_EntityIcon__eq00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_cclass(tolua_S,"EntityIconManager","EmberOgre::Gui::EntityIconManager","",NULL);
    tolua_beginmodule(tolua_S,"EntityIconManager");
     tolua_function(tolua_S,"createSlot",tolua_EmberOgre_EmberOgre_Gui_EntityIconManager_createSlot00);
     tolua_function(tolua_S,"destroySlot",tolua_EmberOgre_EmberOgre_Gui_EntityIconManager_destroySlot00);
     tolua_function(tolua_S,"createIcon",tolua_EmberOgre_EmberOgre_Gui_EntityIconManager_createIcon00);
     tolua_function(tolua_S,"destroyIcon",tolua_EmberOgre_EmberOgre_Gui_EntityIconManager_destroyIcon00);
     tolua_variable(tolua_S,"EventIconDragStart",tolua_get_EmberOgre__Gui__EntityIconManager_EventIconDragStart,tolua_set_EmberOgre__Gui__EntityIconManager_EventIconDragStart);
     tolua_variable(tolua_S,"EventIconDragStop",tolua_get_EmberOgre__Gui__EntityIconManager_EventIconDragStop,tolua_set_EmberOgre__Gui__EntityIconManager_EventIconDragStop);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"EntityIconDragDropTarget","EmberOgre::Gui::EntityIconDragDropTarget","",tolua_collect_EmberOgre__Gui__EntityIconDragDropTarget);
    #else
    tolua_cclass(tolua_S,"EntityIconDragDropTarget","EmberOgre::Gui::EntityIconDragDropTarget","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"EntityIconDragDropTarget");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropTarget_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropTarget_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropTarget_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropTarget_delete00);
     tolua_variable(tolua_S,"EventIconEntered",tolua_get_EmberOgre__Gui__EntityIconDragDropTarget_EventIconEntered,tolua_set_EmberOgre__Gui__EntityIconDragDropTarget_EventIconEntered);
     tolua_variable(tolua_S,"EventIconLeaves",tolua_get_EmberOgre__Gui__EntityIconDragDropTarget_EventIconLeaves,tolua_set_EmberOgre__Gui__EntityIconDragDropTarget_EventIconLeaves);
     tolua_variable(tolua_S,"EventIconDropped",tolua_get_EmberOgre__Gui__EntityIconDragDropTarget_EventIconDropped,tolua_set_EmberOgre__Gui__EntityIconDragDropTarget_EventIconDropped);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"EntityIconDragDropPreview","EmberOgre::Gui::EntityIconDragDropPreview","",tolua_collect_EmberOgre__Gui__EntityIconDragDropPreview);
    #else
    tolua_cclass(tolua_S,"EntityIconDragDropPreview","EmberOgre::Gui::EntityIconDragDropPreview","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"EntityIconDragDropPreview");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_new00_local);
     tolua_function(tolua_S,"createPreview",tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_createPreview00);
     tolua_function(tolua_S,"cleanupCreation",tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_cleanupCreation00);
     tolua_function(tolua_S,"getDropOffset",tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_getDropOffset00);
     tolua_function(tolua_S,"getDropOrientation",tolua_EmberOgre_EmberOgre_Gui_EntityIconDragDropPreview_getDropOrientation00);
     tolua_variable(tolua_S,"EventEntityFinalized",tolua_get_EmberOgre__Gui__EntityIconDragDropPreview_EventEntityFinalized,tolua_set_EmberOgre__Gui__EntityIconDragDropPreview_EventEntityFinalized);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"HelpMessage","EmberOgre::Gui::HelpMessage","",tolua_collect_EmberOgre__Gui__HelpMessage);
    #else
    tolua_cclass(tolua_S,"HelpMessage","EmberOgre::Gui::HelpMessage","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"HelpMessage");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new00_local);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new01);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new01_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_HelpMessage_new01_local);
     tolua_function(tolua_S,"getHelp",tolua_EmberOgre_EmberOgre_Gui_HelpMessage_getHelp00);
     tolua_function(tolua_S,"getId",tolua_EmberOgre_EmberOgre_Gui_HelpMessage_getId00);
     tolua_function(tolua_S,"getTags",tolua_EmberOgre_EmberOgre_Gui_HelpMessage_getTags00);
     tolua_function(tolua_S,"getTitle",tolua_EmberOgre_EmberOgre_Gui_HelpMessage_getTitle00);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"QuickHelp","EmberOgre::Gui::QuickHelp","",NULL);
    tolua_beginmodule(tolua_S,"QuickHelp");
     tolua_function(tolua_S,"getSingleton",tolua_EmberOgre_EmberOgre_Gui_QuickHelp_getSingleton00);
     tolua_function(tolua_S,"updateText",tolua_EmberOgre_EmberOgre_Gui_QuickHelp_updateText00);
     tolua_function(tolua_S,"showWidget",tolua_EmberOgre_EmberOgre_Gui_QuickHelp_showWidget00);
     tolua_variable(tolua_S,"EventToggleWidgetVisibility",tolua_get_EmberOgre__Gui__QuickHelp_EventToggleWidgetVisibility,tolua_set_EmberOgre__Gui__QuickHelp_EventToggleWidgetVisibility);
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"QuickHelpCursor","EmberOgre::Gui::QuickHelpCursor","",tolua_collect_EmberOgre__Gui__QuickHelpCursor);
    #else
    tolua_cclass(tolua_S,"QuickHelpCursor","EmberOgre::Gui::QuickHelpCursor","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"QuickHelpCursor");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_new00_local);
     tolua_function(tolua_S,"nextMessage",tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_nextMessage00);
     tolua_function(tolua_S,"previousMessage",tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_previousMessage00);
     tolua_function(tolua_S,"getSize",tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_getSize00);
     tolua_function(tolua_S,"getCursorLocation",tolua_EmberOgre_EmberOgre_Gui_QuickHelpCursor_getCursorLocation00);
     tolua_variable(tolua_S,"EventUpdateText",tolua_get_EmberOgre__Gui__QuickHelpCursor_EventUpdateText,NULL);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"ActionBarInput","EmberOgre::Gui::ActionBarInput","",tolua_collect_EmberOgre__Gui__ActionBarInput);
    #else
    tolua_cclass(tolua_S,"ActionBarInput","EmberOgre::Gui::ActionBarInput","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"ActionBarInput");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_ActionBarInput_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_ActionBarInput_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_ActionBarInput_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_ActionBarInput_delete00);
     tolua_variable(tolua_S,"EventGotHotkeyInput",tolua_get_EmberOgre__Gui__ActionBarInput_EventGotHotkeyInput,NULL);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_cclass(tolua_S,"EntityTooltip","EmberOgre::Gui::EntityTooltip","",NULL);
    tolua_beginmodule(tolua_S,"EntityTooltip");
     tolua_function(tolua_S,"getTooltipWindow",tolua_EmberOgre_EmberOgre_Gui_EntityTooltip_getTooltipWindow00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_cclass(tolua_S,"ActionBarIconSlot","EmberOgre::Gui::ActionBarIconSlot","EmberOgre::Gui::ActionBarIconDragDropTarget",NULL);
    tolua_beginmodule(tolua_S,"ActionBarIconSlot");
     tolua_function(tolua_S,"addActionBarIcon",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_addActionBarIcon00);
     tolua_function(tolua_S,"removeActionBarIcon",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_removeActionBarIcon00);
     tolua_function(tolua_S,"getActionBarIcon",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_getActionBarIcon00);
     tolua_function(tolua_S,"getWindow",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_getWindow00);
     tolua_function(tolua_S,"notifyIconDraggedOff",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconSlot_notifyIconDraggedOff00);
     tolua_variable(tolua_S,"EventIconDraggedOff",tolua_get_EmberOgre__Gui__ActionBarIconSlot_EventIconDraggedOff,tolua_set_EmberOgre__Gui__ActionBarIconSlot_EventIconDraggedOff);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_cclass(tolua_S,"ActionBarIcon","EmberOgre::Gui::ActionBarIcon","EmberOgre::Gui::ActionBarIconDragDropTarget",NULL);
    tolua_beginmodule(tolua_S,"ActionBarIcon");
     tolua_function(tolua_S,"getImage",tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_getImage00);
     tolua_function(tolua_S,"getDragContainer",tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_getDragContainer00);
     tolua_function(tolua_S,"getIcon",tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_getIcon00);
     tolua_function(tolua_S,"setSlot",tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_setSlot00);
     tolua_function(tolua_S,"getSlot",tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_getSlot00);
     tolua_function(tolua_S,"setTooltipText",tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_setTooltipText00);
     tolua_function(tolua_S,".eq",tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon__eq00);
     tolua_function(tolua_S,"defaultAction",tolua_EmberOgre_EmberOgre_Gui_ActionBarIcon_defaultAction00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_cclass(tolua_S,"ActionBarIconManager","EmberOgre::Gui::ActionBarIconManager","",NULL);
    tolua_beginmodule(tolua_S,"ActionBarIconManager");
     #ifdef __cplusplus
     tolua_cclass(tolua_S,"AvatarIdType","EmberOgre::Gui::ActionBarIconManager::AvatarIdType","",tolua_collect_EmberOgre__Gui__ActionBarIconManager__AvatarIdType);
     #else
     tolua_cclass(tolua_S,"AvatarIdType","EmberOgre::Gui::ActionBarIconManager::AvatarIdType","",NULL);
     #endif
     tolua_beginmodule(tolua_S,"AvatarIdType");
      tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_AvatarIdType_new00);
      tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_AvatarIdType_new00_local);
      tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_AvatarIdType_new00_local);
     tolua_endmodule(tolua_S);
     tolua_function(tolua_S,"createSlot",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_createSlot00);
     tolua_function(tolua_S,"destroySlot",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_destroySlot00);
     tolua_function(tolua_S,"createIcon",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_createIcon00);
     tolua_function(tolua_S,"destroyIcon",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_destroyIcon00);
     tolua_function(tolua_S,"getSavedValue",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_getSavedValue00);
     tolua_function(tolua_S,"saveValue",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_saveValue00);
     tolua_function(tolua_S,"eraseValue",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconManager_eraseValue00);
     tolua_variable(tolua_S,"EventIconDragStart",tolua_get_EmberOgre__Gui__ActionBarIconManager_EventIconDragStart,tolua_set_EmberOgre__Gui__ActionBarIconManager_EventIconDragStart);
     tolua_variable(tolua_S,"EventIconDragStop",tolua_get_EmberOgre__Gui__ActionBarIconManager_EventIconDragStop,tolua_set_EmberOgre__Gui__ActionBarIconManager_EventIconDragStop);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"ActionBarIconDragDropTarget","EmberOgre::Gui::ActionBarIconDragDropTarget","",tolua_collect_EmberOgre__Gui__ActionBarIconDragDropTarget);
    #else
    tolua_cclass(tolua_S,"ActionBarIconDragDropTarget","EmberOgre::Gui::ActionBarIconDragDropTarget","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"ActionBarIconDragDropTarget");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconDragDropTarget_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconDragDropTarget_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconDragDropTarget_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_ActionBarIconDragDropTarget_delete00);
     tolua_variable(tolua_S,"EventIconEntered",tolua_get_EmberOgre__Gui__ActionBarIconDragDropTarget_EventIconEntered,tolua_set_EmberOgre__Gui__ActionBarIconDragDropTarget_EventIconEntered);
     tolua_variable(tolua_S,"EventIconLeaves",tolua_get_EmberOgre__Gui__ActionBarIconDragDropTarget_EventIconLeaves,tolua_set_EmberOgre__Gui__ActionBarIconDragDropTarget_EventIconLeaves);
     tolua_variable(tolua_S,"EventActionBarIconDropped",tolua_get_EmberOgre__Gui__ActionBarIconDragDropTarget_EventActionBarIconDropped,tolua_set_EmberOgre__Gui__ActionBarIconDragDropTarget_EventActionBarIconDropped);
     tolua_variable(tolua_S,"EventEntityIconDropped",tolua_get_EmberOgre__Gui__ActionBarIconDragDropTarget_EventEntityIconDropped,tolua_set_EmberOgre__Gui__ActionBarIconDragDropTarget_EventEntityIconDropped);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Model",0);
   tolua_beginmodule(tolua_S,"Model");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"Model","EmberOgre::Model::Model","",tolua_collect_EmberOgre__Model__Model);
    #else
    tolua_cclass(tolua_S,"Model","EmberOgre::Model::Model","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"Model");
     tolua_function(tolua_S,"createModel",tolua_EmberOgre_EmberOgre_Model_Model_createModel00);
     tolua_function(tolua_S,"createModel",tolua_EmberOgre_EmberOgre_Model_Model_createModel01);
     tolua_function(tolua_S,"reload",tolua_EmberOgre_EmberOgre_Model_Model_reload00);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Model_Model_delete00);
     tolua_function(tolua_S,"addSubmodel",tolua_EmberOgre_EmberOgre_Model_Model_addSubmodel00);
     tolua_function(tolua_S,"removeSubmodel",tolua_EmberOgre_EmberOgre_Model_Model_removeSubmodel00);
     tolua_function(tolua_S,"getAction",tolua_EmberOgre_EmberOgre_Model_Model_getAction00);
     tolua_function(tolua_S,"showPart",tolua_EmberOgre_EmberOgre_Model_Model_showPart00);
     tolua_function(tolua_S,"hidePart",tolua_EmberOgre_EmberOgre_Model_Model_hidePart00);
     tolua_function(tolua_S,"setVisible",tolua_EmberOgre_EmberOgre_Model_Model_setVisible00);
     tolua_function(tolua_S,"getScale",tolua_EmberOgre_EmberOgre_Model_Model_getScale00);
     tolua_function(tolua_S,"getRotation",tolua_EmberOgre_EmberOgre_Model_Model_getRotation00);
     tolua_function(tolua_S,"getUseScaleOf",tolua_EmberOgre_EmberOgre_Model_Model_getUseScaleOf00);
     tolua_function(tolua_S,"getName",tolua_EmberOgre_EmberOgre_Model_Model_getName00);
     tolua_function(tolua_S,"getDefinition",tolua_EmberOgre_EmberOgre_Model_Model_getDefinition00);
     tolua_function(tolua_S,"hasAttachPoint",tolua_EmberOgre_EmberOgre_Model_Model_hasAttachPoint00);
     tolua_function(tolua_S,"hasParticles",tolua_EmberOgre_EmberOgre_Model_Model_hasParticles00);
     tolua_function(tolua_S,"getSubModel",tolua_EmberOgre_EmberOgre_Model_Model_getSubModel00);
     tolua_function(tolua_S,"setDisplaySkeleton",tolua_EmberOgre_EmberOgre_Model_Model_setDisplaySkeleton00);
     tolua_function(tolua_S,"getDisplaySkeleton",tolua_EmberOgre_EmberOgre_Model_Model_getDisplaySkeleton00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Model",0);
   tolua_beginmodule(tolua_S,"Model");
    tolua_cclass(tolua_S,"ModelRepresentation","EmberOgre::Model::ModelRepresentation","EmberOgre::IGraphicalRepresentation",NULL);
    tolua_beginmodule(tolua_S,"ModelRepresentation");
     tolua_constant(tolua_S,"MM_DEFAULT",EmberOgre::Model::ModelRepresentation::MM_DEFAULT);
     tolua_constant(tolua_S,"MM_SWIMMING",EmberOgre::Model::ModelRepresentation::MM_SWIMMING);
     tolua_constant(tolua_S,"MM_WALKING",EmberOgre::Model::ModelRepresentation::MM_WALKING);
     tolua_constant(tolua_S,"MM_RUNNING",EmberOgre::Model::ModelRepresentation::MM_RUNNING);
     tolua_function(tolua_S,"getMovementMode",tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getMovementMode00);
     tolua_function(tolua_S,"getTypeNameForClass",tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getTypeNameForClass00);
     tolua_function(tolua_S,"getEntity",tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getEntity00);
     tolua_function(tolua_S,"getModel",tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getModel00);
     tolua_function(tolua_S,"getWorldBoundingBox",tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getWorldBoundingBox00);
     tolua_function(tolua_S,"getWorldBoundingSphere",tolua_EmberOgre_EmberOgre_Model_ModelRepresentation_getWorldBoundingSphere00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Model",0);
   tolua_beginmodule(tolua_S,"Model");
    tolua_cclass(tolua_S,"ModelRepresentationManager","EmberOgre::Model::ModelRepresentationManager","",NULL);
    tolua_beginmodule(tolua_S,"ModelRepresentationManager");
     tolua_function(tolua_S,"getSingleton",tolua_EmberOgre_EmberOgre_Model_ModelRepresentationManager_getSingleton00);
     tolua_function(tolua_S,"getModelForEntity",tolua_EmberOgre_EmberOgre_Model_ModelRepresentationManager_getModelForEntity00);
     tolua_function(tolua_S,"getRepresentationForEntity",tolua_EmberOgre_EmberOgre_Model_ModelRepresentationManager_getRepresentationForEntity00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Model",0);
   tolua_beginmodule(tolua_S,"Model");
    tolua_cclass(tolua_S,"SubModel","EmberOgre::Model::SubModel","",NULL);
    tolua_beginmodule(tolua_S,"SubModel");
     tolua_function(tolua_S,"getEntity",tolua_EmberOgre_EmberOgre_Model_SubModel_getEntity00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Model",0);
   tolua_beginmodule(tolua_S,"Model");
    tolua_cclass(tolua_S,"ViewDefinition","EmberOgre::Model::ViewDefinition","",NULL);
    tolua_beginmodule(tolua_S,"ViewDefinition");
     tolua_variable(tolua_S,"Name",tolua_get_EmberOgre__Model__ViewDefinition_Name,tolua_set_EmberOgre__Model__ViewDefinition_Name);
     tolua_variable(tolua_S,"Rotation",tolua_get_EmberOgre__Model__ViewDefinition_Rotation,tolua_set_EmberOgre__Model__ViewDefinition_Rotation);
     tolua_variable(tolua_S,"Distance",tolua_get_EmberOgre__Model__ViewDefinition_Distance,tolua_set_EmberOgre__Model__ViewDefinition_Distance);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"AttachPointDefinition","EmberOgre::Model::AttachPointDefinition","",NULL);
    tolua_beginmodule(tolua_S,"AttachPointDefinition");
     tolua_variable(tolua_S,"Name",tolua_get_EmberOgre__Model__AttachPointDefinition_Name,tolua_set_EmberOgre__Model__AttachPointDefinition_Name);
     tolua_variable(tolua_S,"BoneName",tolua_get_EmberOgre__Model__AttachPointDefinition_BoneName,tolua_set_EmberOgre__Model__AttachPointDefinition_BoneName);
     tolua_variable(tolua_S,"Rotation",tolua_get_EmberOgre__Model__AttachPointDefinition_Rotation,tolua_set_EmberOgre__Model__AttachPointDefinition_Rotation);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"SubEntityDefinition","EmberOgre::Model::SubEntityDefinition","",NULL);
    tolua_beginmodule(tolua_S,"SubEntityDefinition");
     tolua_function(tolua_S,"getSubEntityName",tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_getSubEntityName00);
     tolua_function(tolua_S,"getSubEntityIndex",tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_getSubEntityIndex00);
     tolua_function(tolua_S,"getMaterialName",tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_getMaterialName00);
     tolua_function(tolua_S,"setMaterialName",tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_setMaterialName00);
     tolua_function(tolua_S,"getPartDefinition",tolua_EmberOgre_EmberOgre_Model_SubEntityDefinition_getPartDefinition00);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"PartDefinition","EmberOgre::Model::PartDefinition","",NULL);
    tolua_beginmodule(tolua_S,"PartDefinition");
     tolua_function(tolua_S,"setName",tolua_EmberOgre_EmberOgre_Model_PartDefinition_setName00);
     tolua_function(tolua_S,"getName",tolua_EmberOgre_EmberOgre_Model_PartDefinition_getName00);
     tolua_function(tolua_S,"setShow",tolua_EmberOgre_EmberOgre_Model_PartDefinition_setShow00);
     tolua_function(tolua_S,"getShow",tolua_EmberOgre_EmberOgre_Model_PartDefinition_getShow00);
     tolua_function(tolua_S,"createSubEntityDefinition",tolua_EmberOgre_EmberOgre_Model_PartDefinition_createSubEntityDefinition00);
     tolua_function(tolua_S,"createSubEntityDefinition",tolua_EmberOgre_EmberOgre_Model_PartDefinition_createSubEntityDefinition01);
     tolua_function(tolua_S,"getSubEntityDefinitions",tolua_EmberOgre_EmberOgre_Model_PartDefinition_getSubEntityDefinitions00);
     tolua_function(tolua_S,"removeSubEntityDefinition",tolua_EmberOgre_EmberOgre_Model_PartDefinition_removeSubEntityDefinition00);
     tolua_function(tolua_S,"getSubModelDefinition",tolua_EmberOgre_EmberOgre_Model_PartDefinition_getSubModelDefinition00);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"SubModelDefinition","EmberOgre::Model::SubModelDefinition","",NULL);
    tolua_beginmodule(tolua_S,"SubModelDefinition");
     tolua_function(tolua_S,"getMeshName",tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_getMeshName00);
     tolua_function(tolua_S,"createPartDefinition",tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_createPartDefinition00);
     tolua_function(tolua_S,"getPartDefinitions",tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_getPartDefinitions00);
     tolua_function(tolua_S,"removePartDefinition",tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_removePartDefinition00);
     tolua_function(tolua_S,"getModelDefinition",tolua_EmberOgre_EmberOgre_Model_SubModelDefinition_getModelDefinition00);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"ModelDefinition","EmberOgre::Model::ModelDefinition","Ogre::Resource",NULL);
    tolua_beginmodule(tolua_S,"ModelDefinition");
     tolua_constant(tolua_S,"MODEL_ALL",EmberOgre::Model::ModelDefinition::MODEL_ALL);
     tolua_constant(tolua_S,"MODEL_NONE",EmberOgre::Model::ModelDefinition::MODEL_NONE);
     tolua_constant(tolua_S,"MODEL_WIDTH",EmberOgre::Model::ModelDefinition::MODEL_WIDTH);
     tolua_constant(tolua_S,"MODEL_DEPTH",EmberOgre::Model::ModelDefinition::MODEL_DEPTH);
     tolua_constant(tolua_S,"MODEL_HEIGHT",EmberOgre::Model::ModelDefinition::MODEL_HEIGHT);
     tolua_function(tolua_S,"isValid",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_isValid00);
     tolua_function(tolua_S,"setValid",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setValid00);
     tolua_function(tolua_S,"getScale",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getScale00);
     tolua_function(tolua_S,"setScale",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setScale00);
     tolua_function(tolua_S,"getUseScaleOf",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getUseScaleOf00);
     tolua_function(tolua_S,"setUseScaleOf",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setUseScaleOf00);
     tolua_function(tolua_S,"getTranslate",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getTranslate00);
     tolua_function(tolua_S,"setTranslate",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setTranslate00);
     tolua_function(tolua_S,"getShowContained",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getShowContained00);
     tolua_function(tolua_S,"setShowContained",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setShowContained00);
     tolua_function(tolua_S,"getContentOffset",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getContentOffset00);
     tolua_function(tolua_S,"setContentOffset",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setContentOffset00);
     tolua_function(tolua_S,"getRotation",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getRotation00);
     tolua_function(tolua_S,"setRotation",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_setRotation00);
     tolua_function(tolua_S,"createSubModelDefinition",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_createSubModelDefinition00);
     tolua_function(tolua_S,"getSubModelDefinitions",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getSubModelDefinitions00);
     tolua_function(tolua_S,"removeSubModelDefinition",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_removeSubModelDefinition00);
     tolua_function(tolua_S,"createActionDefinition",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_createActionDefinition00);
     tolua_function(tolua_S,"getActionDefinitions",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getActionDefinitions00);
     tolua_function(tolua_S,"removeActionDefinition",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_removeActionDefinition00);
     tolua_function(tolua_S,"getAttachPointsDefinitions",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getAttachPointsDefinitions00);
     tolua_function(tolua_S,"createViewDefinition",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_createViewDefinition00);
     tolua_function(tolua_S,"getViewDefinitions",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_getViewDefinitions00);
     tolua_function(tolua_S,"removeViewDefinition",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_removeViewDefinition00);
     tolua_function(tolua_S,"reloadAllInstances",tolua_EmberOgre_EmberOgre_Model_ModelDefinition_reloadAllInstances00);
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"ModelDefnPtr","EmberOgre::Model::ModelDefnPtr","",tolua_collect_EmberOgre__Model__ModelDefnPtr);
    #else
    tolua_cclass(tolua_S,"ModelDefnPtr","EmberOgre::Model::ModelDefnPtr","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"ModelDefnPtr");
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Model_ModelDefnPtr_delete00);
     tolua_function(tolua_S,"get",tolua_EmberOgre_EmberOgre_Model_ModelDefnPtr_get00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"TerrainPosition","EmberOgre::TerrainPosition","",NULL);
   tolua_beginmodule(tolua_S,"TerrainPosition");
    tolua_function(tolua_S,"isValid",tolua_EmberOgre_EmberOgre_TerrainPosition_isValid00);
    tolua_function(tolua_S,"setToOrigin",tolua_EmberOgre_EmberOgre_TerrainPosition_setToOrigin00);
    tolua_function(tolua_S,"x",tolua_EmberOgre_EmberOgre_TerrainPosition_x00);
    tolua_function(tolua_S,"x",tolua_EmberOgre_EmberOgre_TerrainPosition_x01);
    tolua_function(tolua_S,"y",tolua_EmberOgre_EmberOgre_TerrainPosition_y00);
    tolua_function(tolua_S,"y",tolua_EmberOgre_EmberOgre_TerrainPosition_y01);
   tolua_endmodule(tolua_S);
   tolua_cclass(tolua_S,"Convert","EmberOgre::Convert","",NULL);
   tolua_beginmodule(tolua_S,"Convert");
    tolua_function(tolua_S,"toOgre_Vector3",tolua_EmberOgre_EmberOgre_Convert_toOgre_Vector300);
    tolua_function(tolua_S,"toOgre_Vector2",tolua_EmberOgre_EmberOgre_Convert_toOgre_Vector200);
    tolua_function(tolua_S,"toOgre",tolua_EmberOgre_EmberOgre_Convert_toOgre00);
    tolua_function(tolua_S,"toWF_Point3",tolua_EmberOgre_EmberOgre_Convert_toWF_Point300);
    tolua_function(tolua_S,"toWF_Point2",tolua_EmberOgre_EmberOgre_Convert_toWF_Point200);
    tolua_function(tolua_S,"toWF_Vector3",tolua_EmberOgre_EmberOgre_Convert_toWF_Vector300);
    tolua_function(tolua_S,"toWF",tolua_EmberOgre_EmberOgre_Convert_toWF00);
    tolua_function(tolua_S,"toOgre",tolua_EmberOgre_EmberOgre_Convert_toOgre01);
    tolua_function(tolua_S,"toOgre",tolua_EmberOgre_EmberOgre_Convert_toOgre02);
    tolua_function(tolua_S,"toOgre",tolua_EmberOgre_EmberOgre_Convert_toOgre03);
    tolua_function(tolua_S,"toWF",tolua_EmberOgre_EmberOgre_Convert_toWF01);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"SimpleRenderContext","EmberOgre::SimpleRenderContext","",tolua_collect_EmberOgre__SimpleRenderContext);
   #else
   tolua_cclass(tolua_S,"SimpleRenderContext","EmberOgre::SimpleRenderContext","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"SimpleRenderContext");
    tolua_constant(tolua_S,"CPM_OBJECTCENTER",EmberOgre::SimpleRenderContext::CPM_OBJECTCENTER);
    tolua_constant(tolua_S,"CPM_WORLDCENTER",EmberOgre::SimpleRenderContext::CPM_WORLDCENTER);
    tolua_constant(tolua_S,"CPM_FREE",EmberOgre::SimpleRenderContext::CPM_FREE);
    tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_SimpleRenderContext_new00);
    tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_SimpleRenderContext_new00_local);
    tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_SimpleRenderContext_new00_local);
    tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_SimpleRenderContext_new01);
    tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_SimpleRenderContext_new01_local);
    tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_SimpleRenderContext_new01_local);
    tolua_function(tolua_S,"getSceneNode",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getSceneNode00);
    tolua_function(tolua_S,"getCamera",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getCamera00);
    tolua_function(tolua_S,"getDefaultCameraDistance",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getDefaultCameraDistance00);
    tolua_function(tolua_S,"setActive",tolua_EmberOgre_EmberOgre_SimpleRenderContext_setActive00);
    tolua_function(tolua_S,"showFull",tolua_EmberOgre_EmberOgre_SimpleRenderContext_showFull00);
    tolua_function(tolua_S,"repositionCamera",tolua_EmberOgre_EmberOgre_SimpleRenderContext_repositionCamera00);
    tolua_function(tolua_S,"pitch",tolua_EmberOgre_EmberOgre_SimpleRenderContext_pitch00);
    tolua_function(tolua_S,"yaw",tolua_EmberOgre_EmberOgre_SimpleRenderContext_yaw00);
    tolua_function(tolua_S,"roll",tolua_EmberOgre_EmberOgre_SimpleRenderContext_roll00);
    tolua_function(tolua_S,"setCameraDistance",tolua_EmberOgre_EmberOgre_SimpleRenderContext_setCameraDistance00);
    tolua_function(tolua_S,"getCameraDistance",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getCameraDistance00);
    tolua_function(tolua_S,"getAbsoluteCameraDistance",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getAbsoluteCameraDistance00);
    tolua_function(tolua_S,"getEntityRotation",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getEntityRotation00);
    tolua_function(tolua_S,"resetCameraOrientation",tolua_EmberOgre_EmberOgre_SimpleRenderContext_resetCameraOrientation00);
    tolua_function(tolua_S,"getSceneManager",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getSceneManager00);
    tolua_function(tolua_S,"getRenderTexture",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getRenderTexture00);
    tolua_function(tolua_S,"getTexture",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getTexture00);
    tolua_function(tolua_S,"getCameraRootNode",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getCameraRootNode00);
    tolua_function(tolua_S,"getViewport",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getViewport00);
    tolua_function(tolua_S,"getLight",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getLight00);
    tolua_function(tolua_S,"setBackgroundColour",tolua_EmberOgre_EmberOgre_SimpleRenderContext_setBackgroundColour00);
    tolua_function(tolua_S,"setBackgroundColour",tolua_EmberOgre_EmberOgre_SimpleRenderContext_setBackgroundColour01);
    tolua_function(tolua_S,"setTexture",tolua_EmberOgre_EmberOgre_SimpleRenderContext_setTexture00);
    tolua_function(tolua_S,"getCameraPositionMode",tolua_EmberOgre_EmberOgre_SimpleRenderContext_getCameraPositionMode00);
    tolua_function(tolua_S,"setCameraPositionMode",tolua_EmberOgre_EmberOgre_SimpleRenderContext_setCameraPositionMode00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_cclass(tolua_S,"MovableObjectRenderer","EmberOgre::Gui::MovableObjectRenderer","",NULL);
    tolua_beginmodule(tolua_S,"MovableObjectRenderer");
     tolua_function(tolua_S,"showFull",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_showFull00);
     tolua_function(tolua_S,"setCameraDistance",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setCameraDistance00);
     tolua_function(tolua_S,"getCameraDistance",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getCameraDistance00);
     tolua_function(tolua_S,"getAbsoluteCameraDistance",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getAbsoluteCameraDistance00);
     tolua_function(tolua_S,"getIsInputCatchingAllowed",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getIsInputCatchingAllowed00);
     tolua_function(tolua_S,"setIsInputCatchingAllowed",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setIsInputCatchingAllowed00);
     tolua_function(tolua_S,"setAutoShowFull",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setAutoShowFull00);
     tolua_function(tolua_S,"getAutoShowFull",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getAutoShowFull00);
     tolua_function(tolua_S,"getActive",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getActive00);
     tolua_function(tolua_S,"setActive",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setActive00);
     tolua_function(tolua_S,"getEntityRotation",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getEntityRotation00);
     tolua_function(tolua_S,"resetCameraOrientation",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_resetCameraOrientation00);
     tolua_function(tolua_S,"pitch",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_pitch00);
     tolua_function(tolua_S,"yaw",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_yaw00);
     tolua_function(tolua_S,"roll",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_roll00);
     tolua_function(tolua_S,"updateRender",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_updateRender00);
     tolua_function(tolua_S,"setBackgroundColour",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setBackgroundColour00);
     tolua_function(tolua_S,"setBackgroundColour",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setBackgroundColour01);
     tolua_function(tolua_S,"showAxis",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_showAxis00);
     tolua_function(tolua_S,"hideAxis",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_hideAxis00);
     tolua_function(tolua_S,"getCameraPositionMode",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_getCameraPositionMode00);
     tolua_function(tolua_S,"setCameraPositionMode",tolua_EmberOgre_EmberOgre_Gui_MovableObjectRenderer_setCameraPositionMode00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"OgreEntityRenderer","EmberOgre::Gui::OgreEntityRenderer","EmberOgre::MovableObjectRenderer",tolua_collect_EmberOgre__Gui__OgreEntityRenderer);
    #else
    tolua_cclass(tolua_S,"OgreEntityRenderer","EmberOgre::Gui::OgreEntityRenderer","EmberOgre::MovableObjectRenderer",NULL);
    #endif
    tolua_beginmodule(tolua_S,"OgreEntityRenderer");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_delete00);
     tolua_function(tolua_S,"showEntity",tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_showEntity00);
     tolua_function(tolua_S,"getEntity",tolua_EmberOgre_EmberOgre_Gui_OgreEntityRenderer_getEntity00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"ModelRenderer","EmberOgre::Gui::ModelRenderer","EmberOgre::Gui::MovableObjectRenderer",tolua_collect_EmberOgre__Gui__ModelRenderer);
    #else
    tolua_cclass(tolua_S,"ModelRenderer","EmberOgre::Gui::ModelRenderer","EmberOgre::Gui::MovableObjectRenderer",NULL);
    #endif
    tolua_beginmodule(tolua_S,"ModelRenderer");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_delete00);
     tolua_function(tolua_S,"showModel",tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_showModel00);
     tolua_function(tolua_S,"getModel",tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_getModel00);
     tolua_function(tolua_S,"repositionSceneNode",tolua_EmberOgre_EmberOgre_Gui_ModelRenderer_repositionSceneNode00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"ListHolder","EmberOgre::Gui::ListHolder","",tolua_collect_EmberOgre__Gui__ListHolder);
    #else
    tolua_cclass(tolua_S,"ListHolder","EmberOgre::Gui::ListHolder","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"ListHolder");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_ListHolder_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_ListHolder_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_ListHolder_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_ListHolder_delete00);
     tolua_function(tolua_S,"addItem",tolua_EmberOgre_EmberOgre_Gui_ListHolder_addItem00);
     tolua_function(tolua_S,"insertItem",tolua_EmberOgre_EmberOgre_Gui_ListHolder_insertItem00);
     tolua_function(tolua_S,"removeItem",tolua_EmberOgre_EmberOgre_Gui_ListHolder_removeItem00);
     tolua_function(tolua_S,"resetList",tolua_EmberOgre_EmberOgre_Gui_ListHolder_resetList00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_constant(tolua_S,"MPT_CLICK",EmberOgre::MPT_CLICK);
   tolua_constant(tolua_S,"MPT_DOUBLECLICK",EmberOgre::MPT_DOUBLECLICK);
   tolua_cclass(tolua_S,"MousePickerArgs","EmberOgre::MousePickerArgs","",NULL);
   tolua_beginmodule(tolua_S,"MousePickerArgs");
    tolua_variable(tolua_S,"windowX",tolua_get_EmberOgre__MousePickerArgs_windowX,tolua_set_EmberOgre__MousePickerArgs_windowX);
    tolua_variable(tolua_S,"windowY",tolua_get_EmberOgre__MousePickerArgs_windowY,tolua_set_EmberOgre__MousePickerArgs_windowY);
    tolua_variable(tolua_S,"pickType",tolua_get_EmberOgre__MousePickerArgs_pickType,tolua_set_EmberOgre__MousePickerArgs_pickType);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"EntityPickResult","EmberOgre::EntityPickResult","",tolua_collect_EmberOgre__EntityPickResult);
   #else
   tolua_cclass(tolua_S,"EntityPickResult","EmberOgre::EntityPickResult","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"EntityPickResult");
    tolua_variable(tolua_S,"entity",tolua_get_EmberOgre__EntityPickResult_entity_ptr,tolua_set_EmberOgre__EntityPickResult_entity_ptr);
    tolua_variable(tolua_S,"position",tolua_get_EmberOgre__EntityPickResult_position,tolua_set_EmberOgre__EntityPickResult_position);
    tolua_variable(tolua_S,"distance",tolua_get_EmberOgre__EntityPickResult_distance,tolua_set_EmberOgre__EntityPickResult_distance);
   tolua_endmodule(tolua_S);
   tolua_cclass(tolua_S,"EntityWorldPickListener","EmberOgre::EntityWorldPickListener","",NULL);
   tolua_beginmodule(tolua_S,"EntityWorldPickListener");
    tolua_variable(tolua_S,"EventPickedEntity",tolua_get_EmberOgre__EntityWorldPickListener_EventPickedEntity,NULL);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Model",0);
   tolua_beginmodule(tolua_S,"Model");
    tolua_cclass(tolua_S,"ModelDefinitionManager","EmberOgre::Model::ModelDefinitionManager","Ogre::ResourceManager",NULL);
    tolua_beginmodule(tolua_S,"ModelDefinitionManager");
     tolua_function(tolua_S,"getSingleton",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_getSingleton00);
     tolua_function(tolua_S,"exportScript",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_exportScript00);
     tolua_function(tolua_S,"create",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_create00);
     tolua_function(tolua_S,"getByName",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_getByName00);
     tolua_function(tolua_S,"getAllMeshes",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_getAllMeshes00);
     tolua_function(tolua_S,"getShowModels",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_getShowModels00);
     tolua_function(tolua_S,"setShowModels",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionManager_setShowModels00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Model",0);
   tolua_beginmodule(tolua_S,"Model");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"ModelDefinitionAtlasComposer","EmberOgre::Model::ModelDefinitionAtlasComposer","",tolua_collect_EmberOgre__Model__ModelDefinitionAtlasComposer);
    #else
    tolua_cclass(tolua_S,"ModelDefinitionAtlasComposer","EmberOgre::Model::ModelDefinitionAtlasComposer","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"ModelDefinitionAtlasComposer");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_delete00);
     tolua_function(tolua_S,"compose",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_compose00);
     tolua_function(tolua_S,"composeToStream",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_composeToStream00);
     tolua_function(tolua_S,"composeToFile",tolua_EmberOgre_EmberOgre_Model_ModelDefinitionAtlasComposer_composeToFile00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Authoring",0);
   tolua_beginmodule(tolua_S,"Authoring");
    tolua_cclass(tolua_S,"EntityMover","EmberOgre::Authoring::EntityMover","",NULL);
    tolua_beginmodule(tolua_S,"EntityMover");
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"EntityMoveManager","EmberOgre::Authoring::EntityMoveManager","",NULL);
    tolua_beginmodule(tolua_S,"EntityMoveManager");
     tolua_function(tolua_S,"startMove",tolua_EmberOgre_EmberOgre_Authoring_EntityMoveManager_startMove00);
     tolua_function(tolua_S,"runCommand",tolua_EmberOgre_EmberOgre_Authoring_EntityMoveManager_runCommand00);
     tolua_variable(tolua_S,"EventStartMoving",tolua_get_EmberOgre__Authoring__EntityMoveManager_EventStartMoving,tolua_set_EmberOgre__Authoring__EntityMoveManager_EventStartMoving);
     tolua_variable(tolua_S,"EventFinishedMoving",tolua_get_EmberOgre__Authoring__EntityMoveManager_EventFinishedMoving,tolua_set_EmberOgre__Authoring__EntityMoveManager_EventFinishedMoving);
     tolua_variable(tolua_S,"EventCancelledMoving",tolua_get_EmberOgre__Authoring__EntityMoveManager_EventCancelledMoving,tolua_set_EmberOgre__Authoring__EntityMoveManager_EventCancelledMoving);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Authoring",0);
   tolua_beginmodule(tolua_S,"Authoring");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"GUIAdapter","EmberOgre::Authoring::GUIAdapter","",tolua_collect_EmberOgre__Authoring__GUIAdapter);
    #else
    tolua_cclass(tolua_S,"GUIAdapter","EmberOgre::Authoring::GUIAdapter","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"GUIAdapter");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_delete00);
     tolua_function(tolua_S,"getType",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_getType00);
     tolua_function(tolua_S,"attach",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_attach00);
     tolua_function(tolua_S,"detach",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_detach00);
     tolua_function(tolua_S,"getValue",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_getValue00);
     tolua_function(tolua_S,"setTitle",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_setTitle00);
     tolua_function(tolua_S,"getTitle",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_getTitle00);
     tolua_function(tolua_S,"setTooltip",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_setTooltip00);
     tolua_function(tolua_S,"getTooltip",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_getTooltip00);
     tolua_function(tolua_S,"addSuggestion",tolua_EmberOgre_EmberOgre_Authoring_GUIAdapter_addSuggestion00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Authoring",0);
   tolua_beginmodule(tolua_S,"Authoring");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"EntityRecipe","EmberOgre::Authoring::EntityRecipe","Ogre::Resource",tolua_collect_EmberOgre__Authoring__EntityRecipe);
    #else
    tolua_cclass(tolua_S,"EntityRecipe","EmberOgre::Authoring::EntityRecipe","Ogre::Resource",NULL);
    #endif
    tolua_beginmodule(tolua_S,"EntityRecipe");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_delete00);
     tolua_function(tolua_S,"loadImpl",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_loadImpl00);
     tolua_function(tolua_S,"unloadImpl",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_unloadImpl00);
     tolua_function(tolua_S,"calculateSize",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_calculateSize00);
     tolua_function(tolua_S,"getGUIAdapters",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_getGUIAdapters00);
     tolua_function(tolua_S,"setAuthor",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_setAuthor00);
     tolua_function(tolua_S,"getAuthor",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_getAuthor00);
     tolua_function(tolua_S,"setDescription",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_setDescription00);
     tolua_function(tolua_S,"getDescription",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_getDescription00);
     tolua_function(tolua_S,"createEntity",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipe_createEntity00);
    tolua_endmodule(tolua_S);
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"EntityRecipePtr","EmberOgre::Authoring::EntityRecipePtr","",tolua_collect_EmberOgre__Authoring__EntityRecipePtr);
    #else
    tolua_cclass(tolua_S,"EntityRecipePtr","EmberOgre::Authoring::EntityRecipePtr","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"EntityRecipePtr");
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipePtr_delete00);
     tolua_function(tolua_S,"get",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipePtr_get00);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"GUIAdaptersStore","EmberOgre::Authoring::GUIAdaptersStore","",NULL);
    tolua_beginmodule(tolua_S,"GUIAdaptersStore");
     tolua_cclass(tolua_S,"value_type","EmberOgre::Authoring::GUIAdaptersStore::value_type","",NULL);
     tolua_beginmodule(tolua_S,"value_type");
      tolua_variable(tolua_S,"first",tolua_get_EmberOgre__Authoring__GUIAdaptersStore__value_type_first,NULL);
      tolua_variable(tolua_S,"second",tolua_get_EmberOgre__Authoring__GUIAdaptersStore__value_type_second_ptr,tolua_set_EmberOgre__Authoring__GUIAdaptersStore__value_type_second_ptr);
     tolua_endmodule(tolua_S);
     #ifdef __cplusplus
     tolua_cclass(tolua_S,"const_iterator","EmberOgre::Authoring::GUIAdaptersStore::const_iterator","",tolua_collect_EmberOgre__Authoring__GUIAdaptersStore__const_iterator);
     #else
     tolua_cclass(tolua_S,"const_iterator","EmberOgre::Authoring::GUIAdaptersStore::const_iterator","",NULL);
     #endif
     tolua_beginmodule(tolua_S,"const_iterator");
      tolua_function(tolua_S,"get",tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_const_iterator_get00);
      tolua_function(tolua_S,"next",tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_const_iterator_next00);
      tolua_function(tolua_S,".eq",tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_const_iterator__eq00);
     tolua_endmodule(tolua_S);
     tolua_function(tolua_S,"begin",tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_begin00);
     tolua_function(tolua_S,"theEnd",tolua_EmberOgre_EmberOgre_Authoring_GUIAdaptersStore_theEnd00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static const unsigned char B[] = {
    10,102,117,110, 99,116,105,111,110, 32, 69,109, 98,101,114,
     79,103,114,101, 46, 65,117,116,104,111,114,105,110,103, 46,
     71, 85, 73, 65,100, 97,112,116,101,114,115, 83,116,111,114,
    101, 58,112, 97,105,114,115, 40, 41, 10,108,111, 99, 97,108,
     32, 73, 32, 61, 32,115,101,108,102, 58, 98,101,103,105,110,
     40, 41, 10,108,111, 99, 97,108, 32, 73,101,110,100, 32, 61,
     32,115,101,108,102, 58,116,104,101, 69,110,100, 40, 41, 10,
    114,101,116,117,114,110, 32,102,117,110, 99,116,105,111,110,
     40, 41, 10,105,102, 32, 73, 32,126, 61, 32, 73,101,110,100,
     32,116,104,101,110, 10,108,111, 99, 97,108, 32,118, 97,108,
     32, 61, 32, 73, 58,103,101,116, 40, 41, 10, 73, 32, 61, 32,
     73, 58,110,101,120,116, 40, 41, 10,114,101,116,117,114,110,
     32,118, 97,108, 46,102,105,114,115,116, 44, 32,118, 97,108,
     46,115,101, 99,111,110,100, 10,101,110,100, 10,101,110,100,
     10,101,110,100, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 1");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Authoring",0);
   tolua_beginmodule(tolua_S,"Authoring");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"EntityRecipeManager","EmberOgre::Authoring::EntityRecipeManager","Ogre::ResourceManager",tolua_collect_EmberOgre__Authoring__EntityRecipeManager);
    #else
    tolua_cclass(tolua_S,"EntityRecipeManager","EmberOgre::Authoring::EntityRecipeManager","Ogre::ResourceManager",NULL);
    #endif
    tolua_beginmodule(tolua_S,"EntityRecipeManager");
     tolua_function(tolua_S,"getSingleton",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_getSingleton00);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_delete00);
     tolua_function(tolua_S,"create",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_create00);
     tolua_function(tolua_S,"parseScript",tolua_EmberOgre_EmberOgre_Authoring_EntityRecipeManager_parseScript00);
     tolua_variable(tolua_S,"__Ember__Singleton_EntityRecipeManager___",tolua_get_EmberOgre__Authoring__EntityRecipeManager___Ember__Singleton_EntityRecipeManager___,NULL);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"EntityCreator","EmberOgre::Gui::EntityCreator","",tolua_collect_EmberOgre__Gui__EntityCreator);
    #else
    tolua_cclass(tolua_S,"EntityCreator","EmberOgre::Gui::EntityCreator","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"EntityCreator");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_EntityCreator_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_EntityCreator_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_EntityCreator_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_EntityCreator_delete00);
     tolua_function(tolua_S,"setRecipe",tolua_EmberOgre_EmberOgre_Gui_EntityCreator_setRecipe00);
     tolua_function(tolua_S,"toggleCreateMode",tolua_EmberOgre_EmberOgre_Gui_EntityCreator_toggleCreateMode00);
     tolua_function(tolua_S,"setRandomizeOrientation",tolua_EmberOgre_EmberOgre_Gui_EntityCreator_setRandomizeOrientation00);
     tolua_function(tolua_S,"createEntity",tolua_EmberOgre_EmberOgre_Gui_EntityCreator_createEntity00);
     tolua_function(tolua_S,"cleanupCreation",tolua_EmberOgre_EmberOgre_Gui_EntityCreator_cleanupCreation00);
     tolua_variable(tolua_S,"mWidget",tolua_get_EmberOgre__Gui__EntityCreator_mWidget_ptr,tolua_set_EmberOgre__Gui__EntityCreator_mWidget_ptr);
     tolua_variable(tolua_S,"EventTypeInfoLoaded",tolua_get_EmberOgre__Gui__EntityCreator_EventTypeInfoLoaded,tolua_set_EmberOgre__Gui__EntityCreator_EventTypeInfoLoaded);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Authoring",0);
   tolua_beginmodule(tolua_S,"Authoring");
    tolua_cclass(tolua_S,"AuthoringManager","EmberOgre::Authoring::AuthoringManager","",NULL);
    tolua_beginmodule(tolua_S,"AuthoringManager");
     tolua_function(tolua_S,"displayAuthoringVisualization",tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_displayAuthoringVisualization00);
     tolua_function(tolua_S,"hideAuthoringVisualization",tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_hideAuthoringVisualization00);
     tolua_function(tolua_S,"displaySimpleEntityVisualization",tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_displaySimpleEntityVisualization00);
     tolua_function(tolua_S,"hideSimpleEntityVisualization",tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_hideSimpleEntityVisualization00);
     tolua_function(tolua_S,"startMovement",tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_startMovement00);
     tolua_function(tolua_S,"stopMovement",tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_stopMovement00);
     tolua_function(tolua_S,"getRawTypeInfoRepository",tolua_EmberOgre_EmberOgre_Authoring_AuthoringManager_getRawTypeInfoRepository00);
     tolua_variable(tolua_S,"DisplayAuthoringVisualizations",tolua_get_EmberOgre__Authoring__AuthoringManager_DisplayAuthoringVisualizations,NULL);
     tolua_variable(tolua_S,"HideAuthoringVisualizations",tolua_get_EmberOgre__Authoring__AuthoringManager_HideAuthoringVisualizations,NULL);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Authoring",0);
   tolua_beginmodule(tolua_S,"Authoring");
    tolua_cclass(tolua_S,"RawTypeInfoRepository","EmberOgre::Authoring::RawTypeInfoRepository","",NULL);
    tolua_beginmodule(tolua_S,"RawTypeInfoRepository");
     tolua_function(tolua_S,"getRawTypeData",tolua_EmberOgre_EmberOgre_Authoring_RawTypeInfoRepository_getRawTypeData00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Authoring",0);
   tolua_beginmodule(tolua_S,"Authoring");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"AtlasObjectDecoder","EmberOgre::Authoring::AtlasObjectDecoder","Atlas::Objects::ObjectsDecoder",tolua_collect_EmberOgre__Authoring__AtlasObjectDecoder);
    #else
    tolua_cclass(tolua_S,"AtlasObjectDecoder","EmberOgre::Authoring::AtlasObjectDecoder","Atlas::Objects::ObjectsDecoder",NULL);
    #endif
    tolua_beginmodule(tolua_S,"AtlasObjectDecoder");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_delete00);
     tolua_function(tolua_S,"getLastObject",tolua_EmberOgre_EmberOgre_Authoring_AtlasObjectDecoder_getLastObject00);
     tolua_variable(tolua_S,"EventObjectArrived",tolua_get_EmberOgre__Authoring__AtlasObjectDecoder_EventObjectArrived,NULL);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"std",0);
  tolua_beginmodule(tolua_S,"std");
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_std__string_","std::vector<std::string>","",tolua_collect_std__vector_std__string_);
   #else
   tolua_cclass(tolua_S,"vector_std__string_","std::vector<std::string>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_std__string_");
    tolua_function(tolua_S,"clear",tolua_EmberOgre_std_vector_std__string__clear00);
    tolua_function(tolua_S,"size",tolua_EmberOgre_std_vector_std__string__size00);
    tolua_function(tolua_S,".geti",tolua_EmberOgre_std_vector_std__string___geti00);
    tolua_function(tolua_S,".seti",tolua_EmberOgre_std_vector_std__string___seti00);
    tolua_function(tolua_S,".geti",tolua_EmberOgre_std_vector_std__string___geti01);
    tolua_function(tolua_S,"push_back",tolua_EmberOgre_std_vector_std__string__push_back00);
    tolua_function(tolua_S,"new",tolua_EmberOgre_std_vector_std__string__new00);
    tolua_function(tolua_S,"new_local",tolua_EmberOgre_std_vector_std__string__new00_local);
    tolua_function(tolua_S,".call",tolua_EmberOgre_std_vector_std__string__new00_local);
    tolua_function(tolua_S,"delete",tolua_EmberOgre_std_vector_std__string__delete00);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_EmberOgre__Model__SubModelDefinition__","std::vector<EmberOgre::Model::SubModelDefinition*>","",tolua_collect_std__vector_EmberOgre__Model__SubModelDefinition__);
   #else
   tolua_cclass(tolua_S,"vector_EmberOgre__Model__SubModelDefinition__","std::vector<EmberOgre::Model::SubModelDefinition*>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_EmberOgre__Model__SubModelDefinition__");
    tolua_function(tolua_S,"clear",tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___clear00);
    tolua_function(tolua_S,"size",tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___size00);
    tolua_function(tolua_S,".geti",tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition____geti00);
    tolua_function(tolua_S,".seti",tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition____seti00);
    tolua_function(tolua_S,".geti",tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition____geti01);
    tolua_function(tolua_S,"push_back",tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___push_back00);
    tolua_function(tolua_S,"new",tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___new00);
    tolua_function(tolua_S,"new_local",tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___new00_local);
    tolua_function(tolua_S,".call",tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___new00_local);
    tolua_function(tolua_S,"delete",tolua_EmberOgre_std_vector_EmberOgre__Model__SubModelDefinition___delete00);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_EmberOgre__Model__PartDefinition__","std::vector<EmberOgre::Model::PartDefinition*>","",tolua_collect_std__vector_EmberOgre__Model__PartDefinition__);
   #else
   tolua_cclass(tolua_S,"vector_EmberOgre__Model__PartDefinition__","std::vector<EmberOgre::Model::PartDefinition*>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_EmberOgre__Model__PartDefinition__");
    tolua_function(tolua_S,"clear",tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___clear00);
    tolua_function(tolua_S,"size",tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___size00);
    tolua_function(tolua_S,".geti",tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition____geti00);
    tolua_function(tolua_S,".seti",tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition____seti00);
    tolua_function(tolua_S,".geti",tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition____geti01);
    tolua_function(tolua_S,"push_back",tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___push_back00);
    tolua_function(tolua_S,"new",tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___new00);
    tolua_function(tolua_S,"new_local",tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___new00_local);
    tolua_function(tolua_S,".call",tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___new00_local);
    tolua_function(tolua_S,"delete",tolua_EmberOgre_std_vector_EmberOgre__Model__PartDefinition___delete00);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_EmberOgre__Model__SubEntityDefinition__","std::vector<EmberOgre::Model::SubEntityDefinition*>","",tolua_collect_std__vector_EmberOgre__Model__SubEntityDefinition__);
   #else
   tolua_cclass(tolua_S,"vector_EmberOgre__Model__SubEntityDefinition__","std::vector<EmberOgre::Model::SubEntityDefinition*>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_EmberOgre__Model__SubEntityDefinition__");
    tolua_function(tolua_S,"clear",tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___clear00);
    tolua_function(tolua_S,"size",tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___size00);
    tolua_function(tolua_S,".geti",tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition____geti00);
    tolua_function(tolua_S,".seti",tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition____seti00);
    tolua_function(tolua_S,".geti",tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition____geti01);
    tolua_function(tolua_S,"push_back",tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___push_back00);
    tolua_function(tolua_S,"new",tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___new00);
    tolua_function(tolua_S,"new_local",tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___new00_local);
    tolua_function(tolua_S,".call",tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___new00_local);
    tolua_function(tolua_S,"delete",tolua_EmberOgre_std_vector_EmberOgre__Model__SubEntityDefinition___delete00);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_Eris__Task__","std::vector<Eris::Task*>","",tolua_collect_std__vector_Eris__Task__);
   #else
   tolua_cclass(tolua_S,"vector_Eris__Task__","std::vector<Eris::Task*>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_Eris__Task__");
    tolua_function(tolua_S,"clear",tolua_EmberOgre_std_vector_Eris__Task___clear00);
    tolua_function(tolua_S,"size",tolua_EmberOgre_std_vector_Eris__Task___size00);
    tolua_function(tolua_S,".geti",tolua_EmberOgre_std_vector_Eris__Task____geti00);
    tolua_function(tolua_S,".seti",tolua_EmberOgre_std_vector_Eris__Task____seti00);
    tolua_function(tolua_S,".geti",tolua_EmberOgre_std_vector_Eris__Task____geti01);
    tolua_function(tolua_S,"push_back",tolua_EmberOgre_std_vector_Eris__Task___push_back00);
    tolua_function(tolua_S,"new",tolua_EmberOgre_std_vector_Eris__Task___new00);
    tolua_function(tolua_S,"new_local",tolua_EmberOgre_std_vector_Eris__Task___new00_local);
    tolua_function(tolua_S,".call",tolua_EmberOgre_std_vector_Eris__Task___new00_local);
    tolua_function(tolua_S,"delete",tolua_EmberOgre_std_vector_Eris__Task___delete00);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_EmberOgre__EntityPickResult_","std::vector<EmberOgre::EntityPickResult>","",tolua_collect_std__vector_EmberOgre__EntityPickResult_);
   #else
   tolua_cclass(tolua_S,"vector_EmberOgre__EntityPickResult_","std::vector<EmberOgre::EntityPickResult>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_EmberOgre__EntityPickResult_");
    tolua_function(tolua_S,"clear",tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__clear00);
    tolua_function(tolua_S,"size",tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__size00);
    tolua_function(tolua_S,".geti",tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult___geti00);
    tolua_function(tolua_S,".seti",tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult___seti00);
    tolua_function(tolua_S,".geti",tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult___geti01);
    tolua_function(tolua_S,"push_back",tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__push_back00);
    tolua_function(tolua_S,"new",tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__new00);
    tolua_function(tolua_S,"new_local",tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__new00_local);
    tolua_function(tolua_S,".call",tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__new00_local);
    tolua_function(tolua_S,"delete",tolua_EmberOgre_std_vector_EmberOgre__EntityPickResult__delete00);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"set_std__string_","std::set<std::string>","",tolua_collect_std__set_std__string_);
   #else
   tolua_cclass(tolua_S,"set_std__string_","std::set<std::string>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"set_std__string_");
    tolua_function(tolua_S,"clear",tolua_EmberOgre_std_set_std__string__clear00);
    tolua_function(tolua_S,"size",tolua_EmberOgre_std_set_std__string__size00);
    tolua_function(tolua_S,"new",tolua_EmberOgre_std_set_std__string__new00);
    tolua_function(tolua_S,"new_local",tolua_EmberOgre_std_set_std__string__new00_local);
    tolua_function(tolua_S,".call",tolua_EmberOgre_std_set_std__string__new00_local);
    tolua_function(tolua_S,"delete",tolua_EmberOgre_std_set_std__string__delete00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"Vector3Adapter","EmberOgre::Gui::Vector3Adapter","",tolua_collect_EmberOgre__Gui__Vector3Adapter);
    #else
    tolua_cclass(tolua_S,"Vector3Adapter","EmberOgre::Gui::Vector3Adapter","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"Vector3Adapter");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new00_local);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new01);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new01_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_new01_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_delete00);
     tolua_function(tolua_S,"getValue",tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_getValue00);
     tolua_function(tolua_S,"getOriginalValue",tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_getOriginalValue00);
     tolua_function(tolua_S,"setValue",tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_setValue00);
     tolua_function(tolua_S,"updateGui",tolua_EmberOgre_EmberOgre_Gui_Vector3Adapter_updateGui00);
     tolua_variable(tolua_S,"EventValueChanged",tolua_get_EmberOgre__Gui__Vector3Adapter_EventValueChanged,tolua_set_EmberOgre__Gui__Vector3Adapter_EventValueChanged);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"QuaternionAdapter","EmberOgre::Gui::QuaternionAdapter","",tolua_collect_EmberOgre__Gui__QuaternionAdapter);
    #else
    tolua_cclass(tolua_S,"QuaternionAdapter","EmberOgre::Gui::QuaternionAdapter","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"QuaternionAdapter");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new00_local);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new01);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new01_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new01_local);
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new02);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new02_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_new02_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_delete00);
     tolua_function(tolua_S,"getValue",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_getValue00);
     tolua_function(tolua_S,"getOriginalValue",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_getOriginalValue00);
     tolua_function(tolua_S,"setValue",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_setValue00);
     tolua_function(tolua_S,"updateGui",tolua_EmberOgre_EmberOgre_Gui_QuaternionAdapter_updateGui00);
     tolua_variable(tolua_S,"EventValueChanged",tolua_get_EmberOgre__Gui__QuaternionAdapter_EventValueChanged,tolua_set_EmberOgre__Gui__QuaternionAdapter_EventValueChanged);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Terrain",0);
   tolua_beginmodule(tolua_S,"Terrain");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"Map","EmberOgre::Terrain::Map","",tolua_collect_EmberOgre__Terrain__Map);
    #else
    tolua_cclass(tolua_S,"Map","EmberOgre::Terrain::Map","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"Map");
     tolua_function(tolua_S,"new",tolua_EmberOgre_EmberOgre_Terrain_Map_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberOgre_EmberOgre_Terrain_Map_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberOgre_EmberOgre_Terrain_Map_new00_local);
     tolua_function(tolua_S,"delete",tolua_EmberOgre_EmberOgre_Terrain_Map_delete00);
     tolua_function(tolua_S,"initialize",tolua_EmberOgre_EmberOgre_Terrain_Map_initialize00);
     tolua_function(tolua_S,"getTexture",tolua_EmberOgre_EmberOgre_Terrain_Map_getTexture00);
     tolua_function(tolua_S,"render",tolua_EmberOgre_EmberOgre_Terrain_Map_render00);
     tolua_function(tolua_S,"reposition",tolua_EmberOgre_EmberOgre_Terrain_Map_reposition00);
     tolua_function(tolua_S,"reposition",tolua_EmberOgre_EmberOgre_Terrain_Map_reposition01);
     tolua_function(tolua_S,"setDistance",tolua_EmberOgre_EmberOgre_Terrain_Map_setDistance00);
     tolua_function(tolua_S,"getDistance",tolua_EmberOgre_EmberOgre_Terrain_Map_getDistance00);
     tolua_function(tolua_S,"getResolution",tolua_EmberOgre_EmberOgre_Terrain_Map_getResolution00);
     tolua_function(tolua_S,"setResolution",tolua_EmberOgre_EmberOgre_Terrain_Map_setResolution00);
     tolua_function(tolua_S,"getResolutionMeters",tolua_EmberOgre_EmberOgre_Terrain_Map_getResolutionMeters00);
     tolua_function(tolua_S,"getView",tolua_EmberOgre_EmberOgre_Terrain_Map_getView00);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"MapView","EmberOgre::Terrain::MapView","",NULL);
    tolua_beginmodule(tolua_S,"MapView");
     tolua_function(tolua_S,"reposition",tolua_EmberOgre_EmberOgre_Terrain_MapView_reposition00);
     tolua_function(tolua_S,"getRelativeViewBounds",tolua_EmberOgre_EmberOgre_Terrain_MapView_getRelativeViewBounds00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"OgreInfo","EmberOgre::OgreInfo","",NULL);
   tolua_beginmodule(tolua_S,"OgreInfo");
    tolua_function(tolua_S,"isIndirect",tolua_EmberOgre_EmberOgre_OgreInfo_isIndirect00);
    tolua_function(tolua_S,"createUniqueResourceName",tolua_EmberOgre_EmberOgre_OgreInfo_createUniqueResourceName00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Terrain",0);
   tolua_beginmodule(tolua_S,"Terrain");
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Terrain",0);
   tolua_beginmodule(tolua_S,"Terrain");
    tolua_cclass(tolua_S,"TerrainLayerDefinitionManager","EmberOgre::Terrain::TerrainLayerDefinitionManager","Ogre::ResourceManager",NULL);
    tolua_beginmodule(tolua_S,"TerrainLayerDefinitionManager");
     tolua_cclass(tolua_S,"DefinitionStore","EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore","",NULL);
     tolua_beginmodule(tolua_S,"DefinitionStore");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"const_iterator","EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator","",tolua_collect_EmberOgre__Terrain__TerrainLayerDefinitionManager__DefinitionStore__const_iterator);
      #else
      tolua_cclass(tolua_S,"const_iterator","EmberOgre::Terrain::TerrainLayerDefinitionManager::DefinitionStore::const_iterator","",NULL);
      #endif
      tolua_beginmodule(tolua_S,"const_iterator");
       tolua_function(tolua_S,"get",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_const_iterator_get00);
       tolua_function(tolua_S,"next",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_const_iterator_next00);
      tolua_endmodule(tolua_S);
      tolua_function(tolua_S,"begin",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_begin00);
      tolua_function(tolua_S,"theEnd",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_theEnd00);
      tolua_function(tolua_S,"size",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_DefinitionStore_size00);
     tolua_endmodule(tolua_S);
     tolua_function(tolua_S,"getSingleton",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_getSingleton00);
     tolua_function(tolua_S,"parseScript",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_parseScript00);
     tolua_function(tolua_S,"getDefinitions",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_getDefinitions00);
     tolua_function(tolua_S,"getDefinitionForArea",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_getDefinitionForArea00);
     tolua_function(tolua_S,"getDefinitionForShader",tolua_EmberOgre_EmberOgre_Terrain_TerrainLayerDefinitionManager_getDefinitionForShader00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static const unsigned char B[] = {
    10,102,117,110, 99,116,105,111,110, 32, 69,109, 98,101,114,
     79,103,114,101, 46, 84,101,114,114, 97,105,110, 46, 84,101,
    114,114, 97,105,110, 76, 97,121,101,114, 68,101,102,105,110,
    105,116,105,111,110, 77, 97,110, 97,103,101,114, 46, 68,101,
    102,105,110,105,116,105,111,110, 83,116,111,114,101, 58,105,
    112, 97,105,114,115, 40, 41, 10,108,111, 99, 97,108, 32, 73,
     32, 61, 32,115,101,108,102, 58, 98,101,103,105,110, 40, 41,
     10,108,111, 99, 97,108, 32, 73,101,110,100, 32, 61, 32,115,
    101,108,102, 58,116,104,101, 69,110,100, 40, 41, 10,108,111,
     99, 97,108, 32,105,110,100,101,120, 32, 61, 32, 45, 49, 59,
     10,114,101,116,117,114,110, 32,102,117,110, 99,116,105,111,
    110, 40, 41, 10,105,102, 32,105,110,100,101,120, 32, 43, 32,
     49, 32, 60, 32,115,101,108,102, 58,115,105,122,101, 40, 41,
     32,116,104,101,110, 10,108,111, 99, 97,108, 32,118, 97,108,
     32, 61, 32, 73, 58,103,101,116, 40, 41, 10,105,110,100,101,
    120, 32, 61, 32,105,110,100,101,120, 32, 43, 32, 49, 10, 73,
     32, 61, 32, 73, 58,110,101,120,116, 40, 41, 10,114,101,116,
    117,114,110, 32,105,110,100,101,120, 44, 32,118, 97,108, 10,
    101,110,100, 10,101,110,100, 10,101,110,100, 45, 45, 45, 45,
     45, 45, 45,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 2");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"World","EmberOgre::World","",NULL);
   tolua_beginmodule(tolua_S,"World");
    tolua_function(tolua_S,"getSceneManager",tolua_EmberOgre_EmberOgre_World_getSceneManager00);
    tolua_function(tolua_S,"getView",tolua_EmberOgre_EmberOgre_World_getView00);
    tolua_function(tolua_S,"getAvatar",tolua_EmberOgre_EmberOgre_World_getAvatar00);
    tolua_function(tolua_S,"getMotionManager",tolua_EmberOgre_EmberOgre_World_getMotionManager00);
    tolua_function(tolua_S,"getEntityFactory",tolua_EmberOgre_EmberOgre_World_getEntityFactory00);
    tolua_function(tolua_S,"getMainCamera",tolua_EmberOgre_EmberOgre_World_getMainCamera00);
    tolua_function(tolua_S,"getMovementController",tolua_EmberOgre_EmberOgre_World_getMovementController00);
    tolua_function(tolua_S,"getMoveManager",tolua_EmberOgre_EmberOgre_World_getMoveManager00);
    tolua_function(tolua_S,"getEmberEntity",tolua_EmberOgre_EmberOgre_World_getEmberEntity00);
    tolua_function(tolua_S,"getEntityPickListener",tolua_EmberOgre_EmberOgre_World_getEntityPickListener00);
    tolua_function(tolua_S,"getAuthoringManager",tolua_EmberOgre_EmberOgre_World_getAuthoringManager00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"Scene","EmberOgre::Scene","",NULL);
   tolua_beginmodule(tolua_S,"Scene");
    tolua_function(tolua_S,"getSceneManager",tolua_EmberOgre_EmberOgre_Scene_getSceneManager00);
    tolua_function(tolua_S,"getMainCamera",tolua_EmberOgre_EmberOgre_Scene_getMainCamera00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"EmberOgre","EmberOgre::EmberOgre","",NULL);
   tolua_beginmodule(tolua_S,"EmberOgre");
    tolua_function(tolua_S,"getSingleton",tolua_EmberOgre_EmberOgre_EmberOgre_getSingleton00);
    tolua_function(tolua_S,"getWorld",tolua_EmberOgre_EmberOgre_EmberOgre_getWorld00);
    tolua_function(tolua_S,"getRenderWindow",tolua_EmberOgre_EmberOgre_EmberOgre_getRenderWindow00);
    tolua_variable(tolua_S,"EventCreatedEmberEntityFactory",tolua_get_EmberOgre__EmberOgre_EventCreatedEmberEntityFactory,tolua_set_EmberOgre__EmberOgre_EventCreatedEmberEntityFactory);
    tolua_variable(tolua_S,"EventCreatedAvatarEntity",tolua_get_EmberOgre__EmberOgre_EventCreatedAvatarEntity,tolua_set_EmberOgre__EmberOgre_EventCreatedAvatarEntity);
    tolua_variable(tolua_S,"EventGUIManagerCreated",tolua_get_EmberOgre__EmberOgre_EventGUIManagerCreated,tolua_set_EmberOgre__EmberOgre_EventGUIManagerCreated);
    tolua_variable(tolua_S,"EventGUIManagerInitialized",tolua_get_EmberOgre__EmberOgre_EventGUIManagerInitialized,tolua_set_EmberOgre__EmberOgre_EventGUIManagerInitialized);
    tolua_variable(tolua_S,"EventGUIManagerBeingDestroyed",tolua_get_EmberOgre__EmberOgre_EventGUIManagerBeingDestroyed,tolua_set_EmberOgre__EmberOgre_EventGUIManagerBeingDestroyed);
    tolua_variable(tolua_S,"EventGUIManagerDestroyed",tolua_get_EmberOgre__EmberOgre_EventGUIManagerDestroyed,tolua_set_EmberOgre__EmberOgre_EventGUIManagerDestroyed);
    tolua_variable(tolua_S,"EventOgreBeingDestroyed",tolua_get_EmberOgre__EmberOgre_EventOgreBeingDestroyed,tolua_set_EmberOgre__EmberOgre_EventOgreBeingDestroyed);
    tolua_variable(tolua_S,"EventOgreDestroyed",tolua_get_EmberOgre__EmberOgre_EventOgreDestroyed,tolua_set_EmberOgre__EmberOgre_EventOgreDestroyed);
    tolua_variable(tolua_S,"EventMotionManagerCreated",tolua_get_EmberOgre__EmberOgre_EventMotionManagerCreated,tolua_set_EmberOgre__EmberOgre_EventMotionManagerCreated);
    tolua_variable(tolua_S,"EventTerrainManagerCreated",tolua_get_EmberOgre__EmberOgre_EventTerrainManagerCreated,tolua_set_EmberOgre__EmberOgre_EventTerrainManagerCreated);
    tolua_variable(tolua_S,"EventTerrainManagerDestroyed",tolua_get_EmberOgre__EmberOgre_EventTerrainManagerDestroyed,tolua_set_EmberOgre__EmberOgre_EventTerrainManagerDestroyed);
    tolua_variable(tolua_S,"EventMotionManagerDestroyed",tolua_get_EmberOgre__EmberOgre_EventMotionManagerDestroyed,tolua_set_EmberOgre__EmberOgre_EventMotionManagerDestroyed);
    tolua_variable(tolua_S,"EventMovementControllerCreated",tolua_get_EmberOgre__EmberOgre_EventMovementControllerCreated,tolua_set_EmberOgre__EmberOgre_EventMovementControllerCreated);
    tolua_variable(tolua_S,"EventMovementControllerDestroyed",tolua_get_EmberOgre__EmberOgre_EventMovementControllerDestroyed,tolua_set_EmberOgre__EmberOgre_EventMovementControllerDestroyed);
    tolua_variable(tolua_S,"EventWorldCreated",tolua_get_EmberOgre__EmberOgre_EventWorldCreated,tolua_set_EmberOgre__EmberOgre_EventWorldCreated);
    tolua_variable(tolua_S,"EventWorldDestroyed",tolua_get_EmberOgre__EmberOgre_EventWorldDestroyed,tolua_set_EmberOgre__EmberOgre_EventWorldDestroyed);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_EmberOgre (lua_State* tolua_S) {
 return tolua_EmberOgre_open(tolua_S);
};
#endif

