Example #1
0
	void IntroScene::initScene()
	{
		mSceneMgr = mRoot->createSceneManager( ST_GENERIC , "intro" );
		mCamera = mSceneMgr->createCamera("Cam1");
		mVp = mWindow->addViewport(mCamera);
		mVp->setBackgroundColour(ColourValue(1.0f, 0.0f,0.0f));
		mCamera->setAspectRatio(Real(mVp->getActualWidth())/mVp->getActualHeight());
		mSceneMgr->setAmbientLight( ColourValue( 1, 1, 1 ) );

		Ogre::MaterialManager *matMgr = Ogre::MaterialManager::getSingletonPtr();
		Ogre::MaterialPtr mat = (Ogre::MaterialPtr )matMgr->create("intro2","General");

		mat->getTechnique(0)->getPass(0)->createTextureUnitState("cybernetic.jpg");
		mat->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false);
		mat->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
		mat->getTechnique(0)->getPass(0)->setLightingEnabled(false);

		Ogre::Rectangle2D *rect = new Ogre::Rectangle2D(true);
		rect->setCorners( -1.0 , 1.0 , 1.0 , -1.0 );
		rect->setMaterial("intro2");
		rect->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND);
		SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode("Background");
		node->attachObject(rect);
		AxisAlignedBox aabInf;
		aabInf.setInfinite();
		rect->setBoundingBox(aabInf);
	
	}
Example #2
0
    void renderQueueEnded(uint8 queueGroupId, const Ogre::String& invocation,
                          bool& repeatThisInvocation)
    {
        using namespace Ogre;

        if (queueGroupId == RENDER_QUEUE_6)
        {
            MaterialPtr material;
            // Also init full screen quad while we're at it
            if (!mFullScreenQuad)
            {
                mFullScreenQuad = new Rectangle2D();
                mFullScreenQuad->setCorners(-1,1,1,-1);
                material = mFullScreenQuad->getMaterial()->clone(StringConverter::toString((Ogre::ulong)mFullScreenQuad));
                mFullScreenQuad->setMaterial(material->getName());
                Pass* pass = material->getTechnique(0)->getPass(0);
                pass->setDepthCheckEnabled(false);
                pass->setDepthWriteEnabled(false);
                pass->setFog(true, FOG_NONE);
                pass->setLightingEnabled(true);
                pass->setAmbient(ColourValue::ZERO);
                pass->setDiffuse(ColourValue::ZERO);
                pass->setSpecular(ColourValue::ZERO);
                pass->setSelfIllumination(0, 1, 0);
            }
            else
            {
                material = mFullScreenQuad->getMaterial();
            }
            Pass* pass = material->getTechnique(0)->getPass(0);

            SceneManager* sm = Root::getSingleton()._getCurrentSceneManager();
            RenderSystem* rs = Root::getSingleton().getRenderSystem();

            rs->setStencilBufferParams(
                CMPF_EQUAL,
                0xFFFFFFFF, 0xFFFFFFFF,
                SOP_KEEP,
                SOP_INVERT,
                SOP_INVERT,
                false);
            pass->setColourWriteEnabled(false);
            sm->_injectRenderWithPass(pass, mFullScreenQuad, false);

            rs->setStencilBufferParams(
                CMPF_NOT_EQUAL,
                0, 0xFFFFFFFF,
                SOP_KEEP,
                SOP_KEEP,
                SOP_KEEP,
                false);
            pass->setColourWriteEnabled(true);
            sm->_injectRenderWithPass(pass, mFullScreenQuad, false);

            rs->setStencilCheckEnabled(false);
            rs->setStencilBufferParams();
        }
    }
void Ogre3DRendererPlugin::setupRTT() {
  if(!SBS) return;

  rtt_texture = Ogre::TextureManager::getSingleton().createManual("RttTex", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, mWindow->getWidth(), mWindow->getHeight(), 0, Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET);
  renderTexture = rtt_texture->getBuffer()->getRenderTarget();

  renderTexture->addViewport(mCamera2);
  renderTexture->getViewport(0)->setClearEveryFrame(true);
  renderTexture->getViewport(0)->setBackgroundColour(Ogre::ColourValue::Black);
  renderTexture->getViewport(0)->setOverlaysEnabled(false);

  rtt_texture2 = Ogre::TextureManager::getSingleton().createManual("RttTex2", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, mWindow->getWidth(), mWindow->getHeight(), 0, Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET);
  renderTexture2 = rtt_texture2->getBuffer()->getRenderTarget();

  renderTexture2->addViewport(mCamera2);
  renderTexture2->getViewport(0)->setClearEveryFrame(true);
  renderTexture2->getViewport(0)->setBackgroundColour(Ogre::ColourValue::Black);
  renderTexture2->getViewport(0)->setOverlaysEnabled(false);

  Ogre::Rectangle2D *mMiniScreen = new Ogre::Rectangle2D(true);
  mMiniScreen->setCorners(0.0f, 1.0f, 1.0f, -1.0f);//mMiniScreen->setCorners(0.5f, -0.5f, 1.0f, -1.0f);
  mMiniScreen->setBoundingBox(Ogre::AxisAlignedBox(-100000.0f * Ogre::Vector3::UNIT_SCALE, 100000.0f * Ogre::Vector3::UNIT_SCALE));

  Ogre::SceneNode* miniScreenNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode");
  miniScreenNode->attachObject(mMiniScreen);
  Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getByName("BarrelDistort");
  material->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName("RttTex");
  mMiniScreen->setMaterial("BarrelDistort");



  Ogre::Rectangle2D *mMiniScreen2 = new Ogre::Rectangle2D(true);
  mMiniScreen2->setCorners(-1.0f, 1.0f, 0.0f, -1.0f);
  mMiniScreen2->setBoundingBox(Ogre::AxisAlignedBox(-100000.0f * Ogre::Vector3::UNIT_SCALE, 100000.0f * Ogre::Vector3::UNIT_SCALE));
  Ogre::SceneNode* miniScreenNode2 = mSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode2");
  miniScreenNode2->attachObject(mMiniScreen2);
  Ogre::MaterialPtr material2 = Ogre::MaterialManager::getSingleton().getByName("BarrelDistort");
  material2->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName("RttTex2");
  mMiniScreen2->setMaterial("BarrelDistort");
}
Example #4
0
inline void GUIRadarLayout::DrawPos(unsigned num, Ogre::Vector3 dst_pos, Ogre::Quaternion players_orientation)
{
	Ogre::Rectangle2D *row = Rows.Data[num];
	Ogre::Rectangle2D *obj = Objects.Data[num];
	//dst_pos -= CommonDeclarations::MaxDistForRadar/2;
    Ogre::Quaternion orientation(Ogre::Degree(30), Ogre::Vector3::UNIT_X);
	Ogre::Quaternion player_rotation(players_orientation.getYaw(), Ogre::Vector3::UNIT_Y);
	player_rotation = Ogre::Quaternion(players_orientation.getRoll(), Ogre::Vector3::UNIT_Z) * player_rotation;
	
	Ogre::Vector3 rel_pos = dst_pos, base_pos = rel_pos;

	base_pos.y=0;

	float scr_height = rel_pos.y*ScreenSize / CommonDeclarations::MaxDistForRadar;

	base_pos = orientation * players_orientation * base_pos;
	base_pos = (base_pos / CommonDeclarations::MaxDistForRadar)*ScreenSize;

	base_pos.x += 0.75;
	base_pos.y -= 0.75;

	if (scr_height==0)
		scr_height=0.01;

	float left=base_pos.x-0.0035, top=base_pos.y, right=base_pos.x+0.0035, bottom=base_pos.y+scr_height;    

	//	
	obj->setCorners(base_pos.x-0.01, base_pos.y+0.005, base_pos.x+0.01, base_pos.y-0.005);
	if (scr_height>0)
	{       
		left=base_pos.x-0.0025;
		top=base_pos.y+scr_height;
		right=base_pos.x+0.0025;
		bottom=base_pos.y;
		obj->setMaterial("Radar/ObjMaterialUp");
	} else 
		if (scr_height<0)
		{   
			left=base_pos.x-0.0025;
			top=base_pos.y;
			right=base_pos.x+0.0025;
			bottom=base_pos.y+scr_height;
			obj->setMaterial("Radar/ObjMaterialDn");
		}
		row->setCorners(left, top, right, bottom);	
	
	row->setVisible(true);
	obj->setVisible(true);
}
void SplashScreenState::createScene()
{
	// creation image splash screen
	Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create("SplashScreen", "General");
	material->getTechnique(0)->getPass(0)->createTextureUnitState("splash_screen.jpg");
	material->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false);
	material->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
	material->getTechnique(0)->getPass(0)->setLightingEnabled(false);
	// creation rect
	Ogre::Rectangle2D *rect = new Ogre::Rectangle2D(true);
	rect->setCorners(-1.0, 1.0, 1.0, -1.0);
	rect->setMaterial("SplashScreen");
	// priorité chargement
	rect->setRenderQueueGroup(Ogre::RenderQueueGroupID::RENDER_QUEUE_BACKGROUND);
	// stay visible
	Ogre::AxisAlignedBox aabInf;
	aabInf.setInfinite();
	rect->setBoundingBox(aabInf);
	//
	Ogre::SceneNode* node = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("SplashScreen");
	node->attachObject(rect);
	m_pSceneMgr->setAmbientLight(Ogre::ColourValue(1, 1, 1));
}
void
    GraphicsController::_initBackgroundHdr()
{
    Ogre::Rectangle2D* rect = new Ogre::Rectangle2D(false);
    rect->setCorners(-1.0f, 1.0f, 1.0f, -1.0f);
    rect->setMaterial("PRJZ/HDRBackground");
    rect->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND + 1);
    rect->setBoundingBox(Ogre::AxisAlignedBox(-100000.0*Ogre::Vector3::UNIT_SCALE, 100000.0*Ogre::Vector3::UNIT_SCALE));
    rect->setCastShadows(false);
    rect->setVisibilityFlags(0xf00000);
    Ogre::SceneNode* node = _scnMgr->getRootSceneNode()->createChildSceneNode("HdrBackground");
    node->attachObject(rect);
    node->setVisible(true);
}
Example #7
0
bool GUIRadarLayout::Load()
{
	//
	rect = new Ogre::Rectangle2D(TRUE);
	rect->setMaterial("Radar/Background");	
	rect->getMaterial()->setDepthCheckEnabled(false);
	rect->getMaterial()->setDepthWriteEnabled(false);	
	rect->setRenderQueueGroup(Ogre::RENDER_QUEUE_6-3);
	//rect->setBoundingBox(Ogre::AxisAlignedBox(-1000000 * Ogre::Vector3::UNIT_SCALE, 1000000 * Ogre::Vector3::UNIT_SCALE)); 
	//CommonDeclarations::GetSceneManager()->getRootSceneNode()->attachObject(rect); 
	//rect->setCorners(0.5, -0.5, 1, -1);
	//

	// Create a manual object for 2D	
	//char name[10];
	Ogre::Rectangle2D *row = NULL;
	Ogre::Rectangle2D *obj = NULL;
	//Ogre::AxisAlignedBox aabInf;
	//aabInf.setInfinite();
	
	if (!Ogre::MaterialManager::getSingleton().resourceExists("CompasMaterial"))
	{
		Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().getByName("BaseWhiteNoLighting");
		CompasMaterial = mat->clone("CompasMaterial");
		CompasMaterial->setDepthCheckEnabled(false);
		CompasMaterial->setDepthWriteEnabled(false);
		CompasMaterial->setLightingEnabled(true);
		CompasMaterial->setAmbient(Ogre::ColourValue::Green);
	}

	if (!Ogre::MaterialManager::getSingleton().resourceExists("RadarRowMaterial"))
	{
		Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().getByName("BaseWhiteNoLighting");
		RadarRowMaterial = mat->clone("RadarRowMaterial");
		RadarRowMaterial->setDepthCheckEnabled(false);
		RadarRowMaterial->setDepthWriteEnabled(false);
		RadarRowMaterial->setLightingEnabled(true);
		RadarRowMaterial->setAmbient(Ogre::ColourValue::Red);
	}

	/*if (!Ogre::MaterialManager::getSingleton().resourceExists("RadarObjMaterial"))
	{
		Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().getByName("BaseWhiteNoLighting");
		RadarObjMaterial = mat->clone("RadarObjMaterial");
		RadarObjMaterial->setDepthCheckEnabled(false);
		RadarObjMaterial->setDepthWriteEnabled(false);
		RadarObjMaterial->setLightingEnabled(true);
		RadarObjMaterial->setAmbient(Ogre::ColourValue::Red);
	}*/
	
	for (unsigned i=0;i<CommonDeclarations::RadarObjectsCount;++i)
	{		
		//
		row = new Ogre::Rectangle2D(TRUE);
		row->setMaterial("RadarRowMaterial");		
		row->setRenderQueueGroup(Ogre::RENDER_QUEUE_6-2);		
		//CommonDeclarations::GetSceneManager()->getRootSceneNode()->attachObject(row); 
		//rect->setCorners(0.5, -0.5, 1, -1);
		Rows.Data[i] = row;
		//

		//
		obj = new Ogre::Rectangle2D(TRUE);
		obj->setMaterial("Radar/ObjMaterialUp");
		obj->setRenderQueueGroup(Ogre::RENDER_QUEUE_6-2);		
		//CommonDeclarations::GetSceneManager()->getRootSceneNode()->attachObject(obj); 
		//rect->setCorners(0.5, -0.5, 1, -1);
		Objects.Data[i] = obj;
		//		
	}

    InitCompasRect(CompasRect);
    InitCompasRect(CompasObj);    
		
	return true;
}
Example #8
0
inline void GUIRadarLayout::DrawCompas(Ogre::Quaternion players_orientation)
{
	//static clock_t last_update_time=0;
	//if (clock()-last_update_time<100)
	//	return;
	assert(CompasRect && CompasObj);
	//if (NULL==CompasRect || NULL==CompasObj)
	//	return;
	//last_update_time = clock();
    //CompasTarget;
	if (TargetID>0)
	{
		if (--WaitCompasTargetTimeout>=0)
		{
			CompasRect->setVisible(false);
			CompasObj->setVisible(false);
			return;
		}
		IAAObject *obj  = CommonDeclarations::GetIDObject(TargetID);
		//assert(obj);
		if (NULL==obj)
		{			
			RemoveCompasTarget();		
			return;
		}
		CompasTarget = obj->GetPosition();
	}
    Ogre::Rectangle2D *row = CompasRect;
    Ogre::Rectangle2D *obj = CompasObj;
    //dst_pos -= CommonDeclarations::MaxDistForRadar/2;
    Ogre::Quaternion orientation(Ogre::Degree(30), Ogre::Vector3::UNIT_X);
    Ogre::Quaternion player_rotation(players_orientation.getYaw(), Ogre::Vector3::UNIT_Y);
	player_rotation = Ogre::Quaternion(players_orientation.getRoll(), Ogre::Vector3::UNIT_Z) * player_rotation;

    Ogre::Vector3 pl_pos = CommonDeclarations::GetPlayer()->GetPosition();
    Ogre::Vector3 rel_pos = CompasTarget-pl_pos, base_pos = rel_pos;
	
	base_pos.y=0;

	bool checkpoint_mode=false;
    float scr_height = 0;
    if (rel_pos.squaredLength()>CommonDeclarations::SqMaxDistForRadar) 
    {
		Ogre::Vector3 dist=base_pos;
        AAUtilities::Norm1(dist);        
        base_pos = dist*CommonDeclarations::MaxDistForRadar;
        scr_height=0.01;		
		checkpoint_mode=true;
    } else
    {	
        scr_height =rel_pos.y*ScreenSize / CommonDeclarations::MaxDistForRadar;
    }

    base_pos = orientation * players_orientation * base_pos;
    base_pos = (base_pos / CommonDeclarations::MaxDistForRadar)*ScreenSize;

    base_pos.x += 0.75;
    base_pos.y -= 0.75;

    //	
	if (!checkpoint_mode)
	{
		if (scr_height==0)
			scr_height=0.01;
		float left=base_pos.x-0.005, top=base_pos.y, right=base_pos.x+0.005, bottom=base_pos.y+scr_height;    
		obj->setCorners(base_pos.x-0.01, base_pos.y+0.008, base_pos.x+0.01, base_pos.y-0.008);
		if (scr_height>0)
		{       
			left=base_pos.x-0.0025;
			top=base_pos.y+scr_height;
			right=base_pos.x+0.0025;
			bottom=base_pos.y;
			obj->setMaterial("Radar/CompasObjMaterialUp");
		} else 
			if (scr_height<0)
			{   
				left=base_pos.x-0.0025;
				top=base_pos.y;
				right=base_pos.x+0.0025;
				bottom=base_pos.y+scr_height;
				obj->setMaterial("Radar/CompasObjMaterialDn");
			}
			row->setCorners(left, top, right, bottom);	
			//		

			row->setVisible(true);
			obj->setVisible(true);
	} else
	{
		obj->setMaterial("Radar/CompasFarMaterial");
		obj->setCorners(base_pos.x-0.015, base_pos.y+0.015, base_pos.x+0.015, base_pos.y-0.015);		
		obj->setVisible(true);
	}
	
}
Example #9
0
int initOgreAR(aruco::CameraParameters camParams, unsigned char* buffer, std::string resourcePath)
{
	/// INIT OGRE FUNCTIONS
#ifdef _WIN32
  	root = new Ogre::Root(resourcePath + "plugins_win.cfg", resourcePath + "ogre_win.cfg");
#elif __x86_64__ || __ppc64__
	root = new Ogre::Root(resourcePath + "plugins_x64.cfg", resourcePath + "ogre.cfg");
#else
	root = new Ogre::Root(resourcePath + "plugins.cfg", resourcePath + "ogre.cfg");
#endif
  	if (!root->showConfigDialog()) return -1;
	Ogre::SceneManager* smgr = root->createSceneManager(Ogre::ST_GENERIC);


	/// CREATE WINDOW, CAMERA AND VIEWPORT
    Ogre::RenderWindow* window = root->initialise(true);
	Ogre::Camera *camera;
	Ogre::SceneNode* cameraNode;
	camera = smgr->createCamera("camera");
	camera->setNearClipDistance(0.01f);
	camera->setFarClipDistance(10.0f);
	camera->setProjectionType(Ogre::PT_ORTHOGRAPHIC);
	camera->setPosition(0, 0, 0);
	camera->lookAt(0, 0, 1);
	double pMatrix[16];
	camParams.OgreGetProjectionMatrix(camParams.CamSize,camParams.CamSize, pMatrix, 0.05,10, false);
	Ogre::Matrix4 PM(pMatrix[0], pMatrix[1], pMatrix[2] , pMatrix[3],
			pMatrix[4], pMatrix[5], pMatrix[6] , pMatrix[7],
			pMatrix[8], pMatrix[9], pMatrix[10], pMatrix[11],
			pMatrix[12], pMatrix[13], pMatrix[14], pMatrix[15]);
	camera->setCustomProjectionMatrix(true, PM);
	camera->setCustomViewMatrix(true, Ogre::Matrix4::IDENTITY);
	window->addViewport(camera);
	cameraNode = smgr->getRootSceneNode()->createChildSceneNode("cameraNode");
	cameraNode->attachObject(camera);


	/// CREATE BACKGROUND FROM CAMERA IMAGE
	int width = camParams.CamSize.width;
	int height = camParams.CamSize.height;
	// create background camera image
	mPixelBox = Ogre::PixelBox(width, height, 1, Ogre::PF_R8G8B8, buffer);
	// Create Texture
	mTexture = Ogre::TextureManager::getSingleton().createManual("CameraTexture",Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
		      Ogre::TEX_TYPE_2D,width,height,0,Ogre::PF_R8G8B8,Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE);

	//Create Camera Material
	Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create("CameraMaterial", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
	Ogre::Technique *technique = material->createTechnique();
	technique->createPass();
	material->getTechnique(0)->getPass(0)->setLightingEnabled(false);
	material->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
	material->getTechnique(0)->getPass(0)->createTextureUnitState("CameraTexture");

	Ogre::Rectangle2D* rect = new Ogre::Rectangle2D(true);
	rect->setCorners(-1.0, 1.0, 1.0, -1.0);
	rect->setMaterial("CameraMaterial");

	// Render the background before everything else
	rect->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND);

	// Hacky, but we need to set the bounding box to something big, use infinite AAB to always stay visible
	Ogre::AxisAlignedBox aabInf;
	aabInf.setInfinite();
	rect->setBoundingBox(aabInf);

	// Attach background to the scene
	Ogre::SceneNode* node = smgr->getRootSceneNode()->createChildSceneNode("Background");
	node->attachObject(rect);


	/// CREATE SIMPLE OGRE SCENE
	// add sinbad.mesh
	Ogre::ResourceGroupManager::getSingleton().addResourceLocation(resourcePath + "Sinbad.zip", "Zip", "Popular");
 	Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
	for(int i=0; i<MAX_MARKERS; i++) {
	  Ogre::String entityName = "Marker_" + Ogre::StringConverter::toString(i);
	  Ogre::Entity* ogreEntity = smgr->createEntity(entityName, "Sinbad.mesh");
	  Ogre::Real offset = ogreEntity->getBoundingBox().getHalfSize().y;
	  ogreNode[i] = smgr->getRootSceneNode()->createChildSceneNode();
	  // add entity to a child node to correct position (this way, entity axis is on feet of sinbad)
	  Ogre::SceneNode *ogreNodeChild = ogreNode[i]->createChildSceneNode();
	  ogreNodeChild->attachObject(ogreEntity);
	  // Sinbad is placed along Y axis, we need to rotate to put it along Z axis so it stands up over the marker
	  // first rotate along X axis, then add offset in Z dir so it is over the marker and not in the middle of it
	  ogreNodeChild->rotate(Ogre::Vector3(1,0,0), Ogre::Radian(Ogre::Degree(90)));
	  ogreNodeChild->translate(0,0,offset,Ogre::Node::TS_PARENT);
	  // mesh is too big, rescale!
	  const float scale = 0.006675f;
	  ogreNode[i]->setScale(scale, scale, scale);

	    // Init animation
	  ogreEntity->getSkeleton()->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE);
	  if(i==0)
	  {
        baseAnim[i] = ogreEntity->getAnimationState("HandsClosed");
        topAnim[i] = ogreEntity->getAnimationState("HandsRelaxed");
	  }
	  else if(i==1)
	  {
        baseAnim[i] = ogreEntity->getAnimationState("Dance");
        topAnim[i] = ogreEntity->getAnimationState("Dance");
	  }
	  else if(i==2)
	  {
        baseAnim[i] = ogreEntity->getAnimationState("RunBase");
        topAnim[i] = ogreEntity->getAnimationState("RunTop");
	  }
	  else
	  {
        baseAnim[i] = ogreEntity->getAnimationState("IdleBase");
        topAnim[i] = ogreEntity->getAnimationState("IdleTop");
	  }
	  baseAnim[i]->setLoop(true);
	  topAnim[i]->setLoop(true);
	  baseAnim[i]->setEnabled(true);
	  topAnim[i]->setEnabled(true);
	}


 	/// KEYBOARD INPUT READING
 	size_t windowHnd = 0;
 	window->getCustomAttribute("WINDOW", &windowHnd);
 	im = OIS::InputManager::createInputSystem(windowHnd);
 	keyboard = static_cast<OIS::Keyboard*>(im->createInputObject(OIS::OISKeyboard, true));

	return 1;
}