/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

You may use this sample code for anything you like, it is not covered by the
LGPL like the rest of the engine.
-----------------------------------------------------------------------------
*/

/**
    \file 
        Lighting.h
    \brief
        Shows lighting support in OGRE. Also demonstrates the use of billboards
        and controllers for automatic time-relative behaviour.
*/


#include "ExampleApplication.h"
#include "OgreIlluminationManager.h"
#include "NXOgre.h"
#include "SceneSerializer.h"
#include "Characters.h"

bool highQuality = true;

Scene* NXScene = 0;
FPSPlayer* gFPSPlayer;

bool PP_glowON = true;
bool PP_tonemapON = true;
bool PP_dofON = true;

Real lightpower = 32.0;
Real glowCut = 50.6;
Real glowTimeBlur = 0.6;
Real glowStrech = 1.8;
Real glowCombine = 0.5;

bool hallLightON = true;
bool smokeON = true;
bool smokeVisible = true;
Timer* smokeOffTimer;

ParticleSystem* smokeSystem;

Entity* LightButton;
Entity* SmokeButton;
SceneNode* hlNode;
SceneNode* rlNode;

int targetCount = 6;
Vector3 targets[] = {Vector3(-8.5,-1.3, -9.8),
					Vector3(-9.8,-1.3,-10.7),
					Vector3(-6.5,-1.3,-11.5),
					Vector3(-6.3,-1.3,-9.6),
					Vector3(-7.7,-1.3,-10.6),
					Vector3(-5.4,-1.3,-10.9)};

class Scientist : FrameListener
{
public:
	Scientist(String name, SceneManager* mSceneMgr)
	{
		scientist = mSceneMgr->createEntity(name, "scientist.mesh");
		mNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
		mNode->setPosition(-7.5,-1.3,-11);
		mNode->setScale(0.02,0.02,0.02);
		mNode->attachObject(scientist);
		scientist->setCastShadows(true);
		mNode->_updateBounds();
		animState = scientist->getAnimationState("idle");
		animState->setEnabled(true);

		setPriority(20);	
		Root::getSingleton().addFrameListener(this);

		waitTimer = new Timer();
		waitTimer->reset();

		wait_min = 2000;
		wait_max = 5000;
		waitTime = Math::RangeRandom(wait_min, wait_max);

		targetReached = true;
		movespeed = 0.2;
	}

	bool frameStarted(const FrameEvent& evt)
    {
		animState->addTime(evt.timeSinceLastFrame * 0.75);

		//mNode->translate(movespeed * 0.001 * Vector3(0,0,1), Node::TS_LOCAL);
		
		Vector3 pos = mNode->getWorldPosition();
		dir = target - pos;
		if(!targetReached && dir.length() < 0.05)
		{
			waitTimer->reset();
			targetReached = true;
			animState = scientist->getAnimationState("idle");
			animState->setEnabled(true);
			animState->setLoop(true);
			
			Vector3 look = FPSPlayer::thePlayer->getPosition() - pos;
			look.y = 0;
			look.normalise();
			Vector3 right = -look.crossProduct(Vector3::UNIT_Y);
			Quaternion q; 			
			q.FromAxes(right,Vector3::UNIT_Y, look);
			mNode->setOrientation(q);

		}
				
		if(!targetReached)
		{
			//move forward to target
			mNode->translate(movespeed * evt.timeSinceLastFrame * 2 * Vector3(0,0,1), Node::TS_LOCAL);
		}
		else
		{
			//look for new target
			if(waitTimer->getMilliseconds() > waitTime)
			{
				int nextTarget = (int)(Math::UnitRandom() * targetCount);
				target = targets[nextTarget];
				dir = target - mNode->getWorldPosition();
				dir.normalise();
				Vector3 right = -dir.crossProduct(Vector3::UNIT_Y);
				Quaternion q; 			
				q.FromAxes(right,Vector3::UNIT_Y, dir);
				mNode->setOrientation(q);

				targetReached = false;
				animState = scientist->getAnimationState("walk");
				animState->setEnabled(true);
				animState->setLoop(true);
			}
		}

		return true;
	}

	Entity* scientist;
	SceneNode* mNode;
	Vector3 target;
	Vector3 dir;
	float movespeed;
	bool targetReached;
	Timer* waitTimer;
	AnimationState* animState;
	int wait_min;
	int wait_max;
	int waitTime;

};

// Listener class for frame updates
class SpaceStationFrameListener : public ExampleFrameListener
{
protected:
	
	unsigned long framecount;
	SceneNode* mainLightNode;
	Light* light1;
	Light* light2;
	SceneNode* sysNode;
	
public:
    SpaceStationFrameListener(RenderWindow* window, Camera* maincam, SceneNode* lightNode, Light* l, Light* l2, SceneNode* sysNode)
        :ExampleFrameListener(window, maincam) 
				 
    {
		mainLightNode = lightNode;
		light1 = l;
		light2 = l2;
		framecount = 0;	
		mMoveSpeed /= 50.0;
		this->sysNode = sysNode;

		mStatsOn = false;
		showDebugOverlay(mStatsOn);
		smokeOffTimer = new Timer();
		smokeOffTimer->reset();
    }

    bool frameStarted(const FrameEvent& evt)
    {	
		
		if(smokeOffTimer->getMilliseconds()>10)
		{
			if(smokeVisible)
			{
				smokeVisible = false;
				smokeSystem->setVisible(false);
			}
		}

		float dt = evt.timeSinceLastFrame;
		static float rotate = 0;
		rotate += dt * 100.0;
		hlNode->rotate(Vector3(0,1,0),Radian(-Degree(dt * 100.0)));
		rlNode->rotate(Vector3(0,1,0),Radian(-Degree(dt * 100.0)));
		Vector3 dir(Math::Cos(Radian(Degree(rotate))), -1.4,Math::Sin(Radian(Degree(rotate))));
		dir.normalise();
		if(light1)
			light1->setDirection(dir);

		if(light2)
		{
			Vector3 pos = Vector3(-1.6,3,-25.5)+ Vector3(dir.x, 0, dir.z) * 0.3;
			light2->setPosition(pos);
			dir *= -1;
			dir.y = -2.0;
			dir.normalise();
			light2->setDirection(dir);
		}
		
		return ExampleFrameListener::frameStarted(evt);     
    }
	
	void turnSmokeOff()
	{
		smokeSystem->getEmitter(0)->setEmissionRate(0);
		smokeOffTimer->reset();
		Ogre::Material* blueMat = (Ogre::Material*) MaterialManager::getSingleton().getByName("Station/bluebutton").getPointer();
		blueMat->getTechnique(0)->getPass(0)->setAmbient(0.01,0.01,0.01);
		if(smokeON)
			SmokeButton->getParentSceneNode()->translate(0,0.02,0,Node::TS_LOCAL);			
	}
	void lightbuttonpressed()
	{
		hallLightON = !hallLightON;
				light2->setVisible(hallLightON);
			if(!hallLightON)
			{
				turnSmokeOff();
				smokeON = false;
				
				LightButton->getParentSceneNode()->translate(0,0.02,0,Node::TS_LOCAL);
				Ogre::Material* redMat = (Ogre::Material*) MaterialManager::getSingleton().getByName("Station/redbutton").getPointer();
				redMat->getTechnique(0)->getPass(0)->setAmbient(0.1,0.01,0.01);	
				Ogre::Material* lampMat = (Ogre::Material*) MaterialManager::getSingleton().getByName("Station_lamp").getPointer();
				lampMat->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("color",Vector4(0,0,0,0));	

			}
			else
			{
				LightButton->getParentSceneNode()->translate(0,-0.02,0,Node::TS_LOCAL);
				Ogre::Material* redMat = (Ogre::Material*) MaterialManager::getSingleton().getByName("Station/redbutton").getPointer();
				redMat->getTechnique(0)->getPass(0)->setAmbient(1,0.1,0.1);							
				Ogre::Material* lampMat = (Ogre::Material*) MaterialManager::getSingleton().getByName("Station_lamp").getPointer();
				lampMat->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("color",Vector4(20,20,20,20));		
			}
			
			
						
	}
	void smokebuttonpressed()
	{
		if(hallLightON)
		{
			smokeON = !smokeON;
			if(smokeON)
			{
				smokeSystem->getEmitter(0)->setEmissionRate(3);
				smokeSystem->setVisible(true);
				smokeVisible = true;

				SmokeButton->getParentSceneNode()->translate(0,-0.02,0,Node::TS_LOCAL);
				Ogre::Material* blueMat = (Ogre::Material*) MaterialManager::getSingleton().getByName("Station/bluebutton").getPointer();
				blueMat->getTechnique(0)->getPass(0)->setAmbient(0.1,0.1,1);				
			}
			else
			{
				turnSmokeOff();
				SmokeButton->getParentSceneNode()->translate(0,0.02,0,Node::TS_LOCAL);
			}
				
		}
	}

	bool processUnbufferedKeyInput(const FrameEvent& evt)
    {
		gFPSPlayer->processKeyInputs(mInputDevice);
				
		if (mInputDevice->isKeyDown(KC_ADD) && mTimeUntilNextToggle <= 0)
		{
			if (mInputDevice->isKeyDown(KC_RSHIFT))
				lightpower /= 1.2;
			else
				lightpower *= 1.2;
			light2->setPowerScale(lightpower);
			mTimeUntilNextToggle = 0.2;
				mWindow->setDebugText(String("LightPower ") + StringConverter::toString(lightpower));
		}
		if (mInputDevice->isKeyDown(KC_SUBTRACT) && mTimeUntilNextToggle <= 0)
		{
			if (mInputDevice->isKeyDown(KC_RSHIFT))
				glowCut /= 1.2;
			else
				glowCut *= 1.2;
			Ogre::Material* m = (Ogre::Material*) MaterialManager::getSingleton().getByName("GTP/Station/PostProc/GlowCut").getPointer();
			m->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("cutValue",glowCut);
			mTimeUntilNextToggle = 0.2;
			mWindow->setDebugText(String("GlowCut ") + StringConverter::toString(glowCut));
		}
		if (mInputDevice->isKeyDown(KC_MULTIPLY) && mTimeUntilNextToggle <= 0)
		{
			if (mInputDevice->isKeyDown(KC_RSHIFT))
				glowTimeBlur /= 1.2;
			else
				glowTimeBlur *= 1.2;
			Ogre::Material* m = (Ogre::Material*) MaterialManager::getSingleton().getByName("GTP/Station/PostProc/GlowCut").getPointer();
			m->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("timeBlur", glowTimeBlur);
			mTimeUntilNextToggle = 0.2;
			mWindow->setDebugText(String("GlowTimeBlur ") + StringConverter::toString(glowTimeBlur));
		}
		if (mInputDevice->isKeyDown(KC_M))
		{
			if (mInputDevice->isKeyDown(KC_RSHIFT))
				glowStrech -= 0.01;
			else
				glowStrech += 0.01;
			Ogre::Material* m = (Ogre::Material*) MaterialManager::getSingleton().getByName("GTP/Station/PostProc/GlowBlurH").getPointer();
			m->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("Stretch", glowStrech);
			m = (Ogre::Material*) MaterialManager::getSingleton().getByName("GTP/Station/PostProc/GlowBlurV").getPointer();
			m->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("Stretch", glowStrech);
			mWindow->setDebugText(String("GlowStretch ") + StringConverter::toString(glowStrech));
		}
		if (mInputDevice->isKeyDown(KC_N))
		{
			if (mInputDevice->isKeyDown(KC_RSHIFT))
				glowCombine -= 0.01;
			else
				glowCombine += 0.01;
			Ogre::Material* m = (Ogre::Material*) MaterialManager::getSingleton().getByName("GTP/Station/GlowFinalCombine").getPointer();
			m->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("weight2", glowCombine);
			mTimeUntilNextToggle = 0.2;
			mWindow->setDebugText(String("GlowCombine ") + StringConverter::toString(glowCombine));
		}

		if (mInputDevice->isKeyDown(KC_3) && mTimeUntilNextToggle <= 0)
		{
			PP_glowON = !PP_glowON;
			CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
														"GTP/Station/PostProc/Glow", PP_glowON);
			mTimeUntilNextToggle = 0.2;
		}
		if (mInputDevice->isKeyDown(KC_4) && mTimeUntilNextToggle <= 0)
		{
			PP_tonemapON = !PP_tonemapON;

			CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
														"GTP/PostProc/ToneMap", PP_tonemapON);
			
			mTimeUntilNextToggle = 0.2;
		}
		if (mInputDevice->isKeyDown(KC_5) && mTimeUntilNextToggle <= 0)
		{
			PP_dofON = !PP_dofON;
			CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
														"GTP/Moria/PostProc/DoF", PP_dofON);
			mTimeUntilNextToggle = 0.2;
		}

		if( mInputDevice->isKeyDown( KC_ESCAPE) )
        {            
            return false;
        }
		if (mInputDevice->isKeyDown(KC_F) && mTimeUntilNextToggle <= 0)
        {
            mStatsOn = !mStatsOn;
            showDebugOverlay(mStatsOn);

            mTimeUntilNextToggle = 1;
        }
		if (mInputDevice->isKeyDown(KC_SYSRQ) && mTimeUntilNextToggle <= 0)
        {
			char tmp[20];
			sprintf(tmp, "screenshot_%d.png", ++mNumScreenShots);
            mWindow->writeContentsToFile(tmp);
            mTimeUntilNextToggle = 0.5;
			mWindow->setDebugText(String("Wrote ") + tmp);
        }
		return true;
		//return ExampleFrameListener::processUnbufferedKeyInput(evt);
	}

	bool processUnbufferedMouseInput(const FrameEvent& evt)
	{
		gFPSPlayer->processMouseInputs(mInputDevice);
	//	return ExampleFrameListener::processUnbufferedMouseInput(evt);

		static float lasttime = 0;
		float thistime = Root::getSingleton().getTimer()->getMilliseconds();
		float dt = ((float)(thistime - lasttime))/ 1000.0;
		lasttime = thistime;

		static float buttonChangeTime = 0;
		buttonChangeTime += dt;
		if( mInputDevice->getMouseButton( 1 ) && buttonChangeTime > 0.25)
		{
			buttonChangeTime = 0;
			
			Vector3 PlayerPos = FPSPlayer::thePlayer->getPosition();
			float dist = (PlayerPos - Vector3(-1.5375, -0.73,-27.6)).length();
			if( dist < 1 && FPSPlayer::thePlayer->getDirection().dotProduct(Vector3(0,0,-1))>0)
			{
				if(PlayerPos.x > -1.5375)
				{
					smokebuttonpressed();
				}
				else
				{
					lightbuttonpressed();
				}
			}
		}
		return true;
	}
};

/** Application class */
class SpaceStationApplication : public ExampleApplication
{




protected:
	SceneNode* kupolaNode;
	SceneNode* roomLightNode;
	SceneNode* hallLightNode;
	Light* roomLight;
	Light* hallLight;
	SceneNode *pSysNode;
	
	void loadResources(void)
	{
		// Initialise, parse scripts etc
		ResourceGroupManager::getSingleton().initialiseResourceGroup("Bootstrap");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Basic");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("General");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_EnvMap");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Caustic");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("PostProc");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Particles");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_PathMap");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Diffuse");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_SpaceStation");		
	}

	void createPostproc()
	{		
	/*	CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0),
														"GTP/SpaceStation/PostProc/DoF");
		CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
														"GTP/SpaceStation/PostProc/DoF", true);*/

		CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0),
														"GTP/Station/PostProc/Glow");
		CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
														"GTP/Station/PostProc/Glow", true);
		
		CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0),
														"GTP/PostProc/ToneMap");
		CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
														"GTP/PostProc/ToneMap", true);	
		/*		
		CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0),
														"GTP/PostProc/MotionBlur");
		CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
														"GTP/PostProc/MotionBlur", false);*/
		
	}
    
	void chooseSceneManager()
	{
		mSceneMgr = mRoot->createSceneManager("OctreeSceneManager");
		//mSceneMgr = mRoot->createSceneManager("OcclusionCullingSceneManager");
	}

	void createScene(void) ///TOWERS
    {
		roomLight = hallLight = 0;

		std::string occlusion_cfg("OcclusionCulling.cfg");
		//mSceneMgr->setWorldGeometry(occlusion_cfg);
		
		//Overlay* mainOverlay = OverlayManager::getSingleton().getByName("MORIA/MainOverlay");
		//mainOverlay->show();

		createPostproc();

		OgreIlluminationManager::getSingleton().setMainCamera(mCamera);
		OgreIlluminationManager::getSingleton().setMainViewport(mWindow->getViewport(0));
		 OgreIlluminationManager::getSingleton().setFocusingSM(false);
	   OgreIlluminationManager::getSingleton().setShadowMapSize(700);
	   OgreIlluminationManager::getSingleton().setBlurShadowMap(highQuality);
	   if(highQuality)
		   OgreIlluminationManager::getSingleton().setShadowMapMaterialName(Light::LT_SPOTLIGHT, "GTP/Basic/Distance_Normalized");
	   else
		   OgreIlluminationManager::getSingleton().setShadowMapMaterialName(Light::LT_SPOTLIGHT, "GTP/Basic/Depth");//GTP/Basic/Distance_Normalize
	   OgreIlluminationManager::getSingleton().setShadowMapMaterialName(Light::LT_POINT, "GTP/Basic/Distance_Normalized");
	   OgreIlluminationManager::getSingleton().setUseLISPSM(false);
	   OgreIlluminationManager::getSingleton().joinSharedRuns(false);
				
		Root::getSingleton()._setCurrentSceneManager(mSceneMgr);
		mCamera->setPosition(0,0,0);
		//mCamera->setPosition(0,100,0);
		//mCamera->lookAt(0,-1,0);
		mCamera->setFOVy(Radian(Degree(80)));
		mCamera->setNearClipDistance(0.001);
		mCamera->setFarClipDistance(820);
		// Set ambient light
       // mSceneMgr->setAmbientLight(ColourValue(0.1, 0.1, 0.1));
		//mSceneMgr->setSkyBox(true, "Examples/EveningSkyBox", 500);
		
		SceneNode* rootNode = mSceneMgr->getRootSceneNode();
		
		SceneSerializer s(mSceneMgr);
		DataStreamPtr inputStream; 				
		inputStream = ResourceGroupManager::getSingleton().openResource("station.level");	
		World* NXWorld = new World("FrameListener: no, log: html");
		NXWorld->getPhysXDriver()->createFrameListener(90);
		NXScene = NXWorld->createScene("Main", mSceneMgr, "gravity: yes, floor: no"); 
		s.setScene(NXScene);
		s.setWorld(NXWorld);
		s.parseScript(inputStream, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
		s.parseEntryPoints("StationPrmEntryPoints.text");
	
		NXScene->createActor("bound", new MeshShape("stationbound.mesh"), Vector3(0,0,0), "static: yes"); 
		NXScene->createActor("bound2", new MeshShape("stationbound2.mesh"), Vector3(0,0,0), "static: yes"); 
		
		hallLight = mSceneMgr->createLight("hallLight");
		hallLight->setType(Light::LT_SPOTLIGHT);
		hallLight->setCastShadows(true);
        hallLight->setDiffuseColour(ColourValue::White);
		hallLight->setSpecularColour(ColourValue::White);
		hallLightNode = rootNode->createChildSceneNode();
		
		//hallLightNode->setPosition(-1.6,3,-25.5);		
		hallLight->setPowerScale(200);
		hallLight->setDirection(0,0,-1);
		hallLightNode->attachObject(hallLight);
		hallLight->setSpotlightRange(Degree(0),Degree(140));
		hallLight->setAttenuation(20.0, 0, 0, 3);
		hallLight->setVisible(hallLightON);

		
		roomLight = mSceneMgr->createLight("roomLight");
		roomLight->setType(Light::LT_SPOTLIGHT);
		roomLight->setCastShadows(true);
        roomLight->setDiffuseColour(ColourValue::White);
		roomLight->setSpecularColour(ColourValue::White);
		roomLightNode = rootNode->createChildSceneNode();
		
		roomLightNode->setPosition(-7.5,1,-11);		
		roomLight->setPowerScale(50);
		roomLight->setDirection(0,0,-1);
		roomLightNode->attachObject(roomLight);
		roomLight->setSpotlightRange(Degree(0),Degree(140));
		roomLight->setAttenuation(20.0, 0, 0, 3);
	/*
		BillboardSet* bbs = mSceneMgr->createBillboardSet("bb", 1);
		bbs->setDefaultDimensions(0.3, 0.3);
		bbs->createBillboard(Vector3::ZERO, ColourValue::White);
		bbs->setMaterialName("Flare");
		roomLightNode->attachObject(bbs);*/


		Entity* CauCaster = mSceneMgr->createEntity("CauCaster", "sphere.mesh");
		SceneNode* casterNode = rootNode->createChildSceneNode();
		casterNode->setPosition(-1.5, 1.0, -25);
		casterNode->setScale(0.75, .75, 0.75);
		CauCaster->setMaterialName("SpaceStation_CausticCaster");
		casterNode->attachObject(CauCaster);
		casterNode->_updateBounds();
		CauCaster->setCastShadows(true);

		smokeSystem = mSceneMgr->createParticleSystem("psys1", "GTP/Station/Smoke");
		smokeSystem->setKeepParticlesInLocalSpace(false);
		SceneNode *pSysNode = rootNode->createChildSceneNode("psys1");
		pSysNode->attachObject(smokeSystem);
		smokeSystem->getEmitter(0)->setPosition(Vector3(0,-3.7,0));
		smokeSystem->setCastShadows(false);
		pSysNode->setPosition(-1.5, 3, -25);
		smokeSystem->setVisible(smokeVisible);

		LightButton = mSceneMgr->createEntity("lightButton", "cube.mesh");
		SceneNode* lbNode = rootNode->createChildSceneNode();
		lbNode->setScale(0.1,0.1,0.1);
		lbNode->setPosition(-1.8, -0.73, -27.6);
		lbNode->rotate(Vector3(1,0,0), Degree(30.0));
		lbNode->attachObject(LightButton);
		lbNode->translate(0,-0.02,0,Node::TS_LOCAL);
		LightButton->setMaterialName("Station/redbutton");
		
		SmokeButton = mSceneMgr->createEntity("smokeButton", "cube.mesh");
		SceneNode* sbNode = rootNode->createChildSceneNode();
		sbNode->setScale(0.1,0.1,0.1);
		sbNode->setPosition(-1.25, -0.73, -27.6);
		sbNode->rotate(Vector3(1,0,0), Degree(30.0));
		sbNode->attachObject(SmokeButton);
		sbNode->translate(0,-0.02,0,Node::TS_LOCAL);
		SmokeButton->setMaterialName("Station/bluebutton");		

		Entity* hallLampHolder = mSceneMgr->createEntity("hallLampHolder", "hallLampHolder.mesh");
		SceneNode* hlhNode = rootNode->createChildSceneNode();
		hlhNode->setPosition(-1.547, 4.308, -24.242);
		hlhNode->attachObject(hallLampHolder);

		Entity* hallLamp = mSceneMgr->createEntity("hallLamp", "hallLamp.mesh");
		hlNode = rootNode->createChildSceneNode();
		hlNode->setPosition(-1.547, 2.899, -24.242);
		hlNode->attachObject(hallLamp);
		hallLamp->setCastShadows(false);

		Entity* roomLamp = mSceneMgr->createEntity("roomLamp", "roomLamp.mesh");
		rlNode = rootNode->createChildSceneNode();
		rlNode->setPosition(-7.579, 1.000, -10.831);
		rlNode->attachObject(roomLamp);	
		rlNode->rotate(Vector3(0,1,0),Radian(Degree(180)));
		roomLamp->setCastShadows(false);

		new Scientist("scientist", mSceneMgr);
		PlayerCharacter::frameListenerPriority = 30;
	
		gFPSPlayer = new FPSPlayer(NXScene, mSceneMgr, Vector3(0.4, 1.0, 0.35),/*Vector3(-7.5,0.0,-11)*/Vector3(0, 0.0, 11.5), 1.15, mCamera, false);
		/*gFPSPlayer->addPlayerMesh("FPSarm.mesh", 0.02, false);
		gFPSPlayer->addWeaponModel("sword.mesh", "joint28");
	
		TrollCharacter* troll = new TrollCharacter("troll1", NXScene, mSceneMgr, Vector3(1.5, 3.0, 1.2), Vector3(15, 10, 15), false);
		troll->addPlayerMesh("troll.mesh", 0.05, false);
		troll->addWeaponModel("trollMace.mesh", "RightHand");

		CharacterManager::getSingleton().mScene = NXScene;
		CharacterManager::getSingleton().mSceneManager = mSceneMgr;*/

		OgreIlluminationManager::getSingleton().initTechniques();
   }
	
	void createPlane(Ogre::String _name, Ogre::String _material, Ogre::Vector3 _pos, Ogre::Vector2 _size, Ogre::Vector2 _subdivisions = Ogre::Vector2(1,1)) 
	{
		Plane _plane;
        _plane.normal = Vector3::UNIT_Y;
        _plane.d = 0;


        MeshManager::getSingleton().createPlane(_name + ".plane",
            ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, 
            _plane,_size.x,_size.y,1,1,true,1,_subdivisions.x,_subdivisions.y,Vector3::UNIT_Z);
        
		Entity *_entity = mSceneMgr->createEntity(_name + ".entity", _name + ".plane");
        _entity->setMaterialName(_material);

		SceneNode* _node = mSceneMgr->getRootSceneNode()->createChildSceneNode(_name + ".node");
		_node->attachObject(_entity);
		_node->setPosition(_pos);

	}

	void createFrameListener(void)
    {
		// This is where we instantiate our own frame listener
		mFrameListener= new SpaceStationFrameListener(mWindow,
			mCamera, roomLightNode, roomLight, hallLight, pSysNode	);
        mFrameListener->setPriority(10);	
		mRoot->addFrameListener(mFrameListener);
//		gFPSPlayer->setPriority(20);
//		mRoot->addFrameListener(gFPSPlayer);
		OgreIlluminationManager::getSingleton().setPriority(100);
	    mRoot->addFrameListener(&OgreIlluminationManager::getSingleton());
	  
    }

};