/*
-----------------------------------------------------------------------------
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 "SpriteParticleRenderer.h"
#include "FrameCapture.h"
#include "OgreCausticCubeMapRenderingRun.h"

float worldSizeVar = 0.002;
float refIndex = 0.8;
int scene = 2;
FrameCapture* capture;

bool multiplebounce = true;
bool useCauInt = true;

int currentMaterial = 0;
int currentObject = 1;
String objectNames[] = {String("sphere.mesh"),
                        String("teapot.mesh"),
						String("colorcube.mesh"),
						String("head.mesh")};

float objectscales[] = {0.015,1.7,1,0.1};
float scenescales[] = {0.3,1, 2.7};

String materialNames[] = {String("GTP/MultiBounce/Reflector"),
							String("GTP/MultiBounce/Refractor"),
							String("GTP/MultiBounce/CausticRefractor"),
							String("GTP/MultiBounce/Reflector_MinMax"),
							String("GTP/MultiBounce/Refractor_MinMax"),
							String("GTP/MultiBounce/CausticRefractor_MinMax"),
							String("semmi")
							};
                        
String resourceGroupName[] = {	String("GTP_MultipleReflection"),
								String("GTP_MultipleRefraction"),
								String("GTP_MultipleRefraction"),
								String("GTP_MultipleReflection_MinMax"),
								String("GTP_MultipleRefraction_MinMax"),
								String("GTP_MultipleRefraction_MinMax"),
								String("GTP_Basic")};

// Listener class for frame updates
class RaytraceDemoListener : public ExampleFrameListener
{
protected:
	unsigned long framecount;
	SceneNode* objectNode;
	Entity *object;
	
public:
	void setMoveSpeed(float speed){mMoveSpeed = speed;}
    RaytraceDemoListener(RenderWindow* window, Camera* maincam, SceneNode* objectNode, Entity* object)
        :ExampleFrameListener(window, maincam) 
				 
    {
		this->object = object;
		this->mMoveSpeed = 1;
		if(scene == 2)
		this->mMoveSpeed = 1.0;
		if(scene == 3)
		this->mMoveSpeed = 10.0;
		 mStatsOn = false;
		 showDebugOverlay(mStatsOn);

		framecount = 0;		
		this->objectNode = objectNode;		
		
    }

	void moveCamera()
    {/*
	   mCamera->yaw(mRotX);
       mCamera->pitch(mRotY);
       mCamera->moveRelative(mTranslateVector);*/

		mCamera->getParentSceneNode()->yaw(mRotX, Node::TransformSpace::TS_WORLD);
		mCamera->getParentSceneNode()->pitch(mRotY, Node::TransformSpace::TS_LOCAL);
		mCamera->getParentSceneNode()->translate(mTranslateVector, Node::TransformSpace::TS_LOCAL);
		
    }

	bool processUnbufferedKeyInput(const FrameEvent& evt)
    {
		if (mInputDevice->isKeyDown(KC_F2) && mTimeUntilNextToggle <= 0)
        {
			TexturePtr tex = TextureManager::getSingleton().getByName("SCREENSHOT");
			tex->getBuffer()->getRenderTarget()->update();
			tex->getBuffer()->getRenderTarget()->writeContentsToFile(String("screen") + StringConverter::toString(framecount) + ".tga");
            mTimeUntilNextToggle = 0.5;            
        }

		static float lastTime = 0.0;
		float thisTime = (float) Root::getSingleton().getTimer()->getMilliseconds() / 1000.0f;
		float elapsed = thisTime - lastTime;
		float move = elapsed * 0.5;
		if(scene == 3 )
			move *= 10;
		float rotate = 80.0 * move;
		if (mInputDevice->isKeyDown(KC_G))
        {
			worldSizeVar -= 0.002;
			if(worldSizeVar < 0.002)worldSizeVar = 0.002;
			MaterialPtr mat = MaterialManager::getSingleton().getByName("GTP/MultiBounce/CauCube_Triangles_clone_object_SE_0");
			if(!mat.isNull())
			{
				GpuProgramParameters* Vparams = mat->getTechnique(0)->getPass(0)->getVertexProgramParameters().getPointer();
			  Vparams->setNamedConstant("WorldSize", worldSizeVar);
			}
		}
		if (mInputDevice->isKeyDown(KC_H))
        {
			worldSizeVar += 0.002;
			MaterialPtr mat = MaterialManager::getSingleton().getByName("GTP/MultiBounce/CauCube_Triangles_clone_object_SE_0");
			if(!mat.isNull())
			{
				GpuProgramParameters* Vparams = mat->getTechnique(0)->getPass(0)->getVertexProgramParameters().getPointer();
			  Vparams->setNamedConstant("WorldSize", worldSizeVar);
			}
		}
		if (mInputDevice->isKeyDown(KC_I) && mTimeUntilNextToggle <= 0)
        {			
			useCauInt = !useCauInt;

			MaterialPtr mat = MaterialManager::getSingleton().getByName("GTP/MultiBounce/CauCube_Triangles_clone_object_SE_0");
			if(!mat.isNull())
			{
			  GpuProgramParameters* Vparams = mat->getTechnique(0)->getPass(0)->getVertexProgramParameters().getPointer();
			  Vparams->setNamedConstant("notUseIntensity", !useCauInt);
			  if(useCauInt)
			  {
				  mat->getTechnique(0)->getPass(0)->setPolygonMode(PM_SOLID);
				  OgreTechniqueGroup* tg = (OgreTechniqueGroup*) object->getSubEntity(0)->getRenderTechniqueGroup();
				  OgreCausticCubeMapRenderingRun* rr = (OgreCausticCubeMapRenderingRun*) 
								tg->getSharedRuns()->getRun(ILLUMRUN_CAUSTIC_CUBEMAP)
								->asOgreRenderingRun();
				  rr->setBlurMap(true);
			  }
			  else
			  {
				   mat->getTechnique(0)->getPass(0)->setPolygonMode(PM_POINTS);
				   OgreTechniqueGroup* tg = (OgreTechniqueGroup*) object->getSubEntity(0)->getRenderTechniqueGroup();
				  OgreCausticCubeMapRenderingRun* rr = (OgreCausticCubeMapRenderingRun*) 
								tg->getSharedRuns()->getRun(ILLUMRUN_CAUSTIC_CUBEMAP)
								->asOgreRenderingRun();
				  rr->setBlurMap(false);
			  }
			}
			mTimeUntilNextToggle = 1;
        }
		if (mInputDevice->isKeyDown(KC_J))
        {			
			refIndex -= 0.01;

			MaterialPtr mat1 = MaterialManager::getSingleton().getByName(materialNames[currentMaterial]+"_clone_object_SE_0");
			if(!mat1.isNull())
			{
			  GpuProgramParameters* Fparams1 = mat1->getTechnique(0)->getPass(0)->getFragmentProgramParameters().getPointer();
			  Fparams1->setNamedConstant("refIndex", refIndex);
			}
			//MaterialPtr mat2 = MaterialManager::getSingleton().getByName("GTP/MultiBounce/PhotonMap");
			MaterialPtr mat2 = MaterialManager::getSingleton().getByName("GTP/Caustic/PhotonMap_HitEnv");
			if(!mat2.isNull())
			{
			  GpuProgramParameters* Fparams2 = mat2->getTechnique(0)->getPass(0)->getFragmentProgramParameters().getPointer();
			  Fparams2->setNamedConstant("refIndex", refIndex);
			}
        }
		if (mInputDevice->isKeyDown(KC_K))
        {
			refIndex += 0.01;
			
			MaterialPtr mat1 = MaterialManager::getSingleton().getByName(materialNames[currentMaterial]+"_clone_object_SE_0");
			if(!mat1.isNull())
			{
			  GpuProgramParameters* Fparams1 = mat1->getTechnique(0)->getPass(0)->getFragmentProgramParameters().getPointer();
			  Fparams1->setNamedConstant("refIndex", refIndex);
			}
			//MaterialPtr mat2 = MaterialManager::getSingleton().getByName("GTP/MultiBounce/PhotonMap");
			MaterialPtr mat2 = MaterialManager::getSingleton().getByName("GTP/Caustic/PhotonMap_HitEnv");
			if(!mat2.isNull())
			{
			  GpuProgramParameters* Fparams2 = mat2->getTechnique(0)->getPass(0)->getFragmentProgramParameters().getPointer();
			  Fparams2->setNamedConstant("refIndex", refIndex);
			}
        }

		if (mInputDevice->isKeyDown(KC_UP))
        {
			objectNode->translate(0,0,move);
        }
		if (mInputDevice->isKeyDown(KC_MULTIPLY))
        {
			//objectNode->scale(1.1,1.1,1.1);
			objectNode->rotate(Vector3(0,0,1), Degree(rotate));
			
        }
		if (mInputDevice->isKeyDown(KC_DIVIDE))
        {
			//objectNode->scale(1.0/1.1,1.0/1.1,1.0/1.1);
			objectNode->rotate(Vector3(1,0,0), Degree(rotate));
			
        }
		if (mInputDevice->isKeyDown(KC_ADD))
        {
			objectNode->rotate(Vector3(0,1,0), Degree(rotate));
        }
		if (mInputDevice->isKeyDown(KC_HOME))
        {
			objectNode->translate(0,move,0);
        }
		if (mInputDevice->isKeyDown(KC_END))
        {
			objectNode->translate(0,-move,0);
        }
		if (mInputDevice->isKeyDown(KC_DOWN))
        {
			objectNode->translate(0,0,-move);
        }
		if (mInputDevice->isKeyDown(KC_RIGHT))
        {
			objectNode->translate(-move,0,0);
        }
		if (mInputDevice->isKeyDown(KC_LEFT))
        {
			objectNode->translate(move,0,0);
        }

		if (mInputDevice->isKeyDown(KC_A))
        {
            // Move camera left
            mTranslateVector.x = -mMoveScale;
        }

        if (mInputDevice->isKeyDown(KC_D))
        {
            // Move camera RIGHT
            mTranslateVector.x = mMoveScale;
        }

        /* Move camera forward by keypress. */
        if ( mInputDevice->isKeyDown(KC_W) )
        {
            mTranslateVector.z = -mMoveScale;
        }
		
        /* Move camera backward by keypress. */
        if (mInputDevice->isKeyDown(KC_S) )
        {
            mTranslateVector.z = mMoveScale;
        }

        if (mInputDevice->isKeyDown(KC_PGUP))
        {
            // Move camera up
            mTranslateVector.y = mMoveScale;
        }

        if (mInputDevice->isKeyDown(KC_PGDOWN))
        {
            // Move camera down
            mTranslateVector.y = -mMoveScale;
        }
		if (mInputDevice->isKeyDown(KC_N) && mTimeUntilNextToggle <= 0)
        {
			capture->playEvent();
            mTimeUntilNextToggle = 1;
        }
		if (mInputDevice->isKeyDown(KC_B) && mTimeUntilNextToggle <= 0)
        {
			capture->recordEvent();
            mTimeUntilNextToggle = 1;
        }
		if (mInputDevice->isKeyDown(KC_M) && mTimeUntilNextToggle <= 0)
        {
			capture->setSaving();
			capture->playEvent();
            mTimeUntilNextToggle = 1;
        }	

        if( mInputDevice->isKeyDown( KC_ESCAPE) )
        {            
            return false;
        }

		// see if switching is on, and you want to toggle 
        if (mInputTypeSwitchingOn && mInputDevice->isKeyDown(KC_M) && mTimeUntilNextToggle <= 0)
        {
			switchMouseMode();
            mTimeUntilNextToggle = 1;
        }

        if (mInputTypeSwitchingOn && mInputDevice->isKeyDown(KC_K) && mTimeUntilNextToggle <= 0)
        {
			// must be going from immediate keyboard to buffered keyboard
			switchKeyMode();
            mTimeUntilNextToggle = 1;
        }
        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);
        }
		
		static bool displayCameraDetails = false;
        if (mInputDevice->isKeyDown(KC_P) && mTimeUntilNextToggle <= 0)
        {
            displayCameraDetails = !displayCameraDetails;
            mTimeUntilNextToggle = 0.5;
            if (!displayCameraDetails)
                mWindow->setDebugText("");
        }
        if (displayCameraDetails)
        {
            // Print camera details
            mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) + " " + 
                "O: " + StringConverter::toString(mCamera->getDerivedOrientation()));
        }
        lastTime = thisTime;
        // Return true to continue rendering
        return true;
	}
    bool frameStarted(const FrameEvent& evt)
    {
		bool result = ExampleFrameListener::frameStarted(evt);
		framecount++;
		return result;     
    }
};

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

public:


protected:

	SceneNode* objectNode;
	Texture* screenTexture;

    void createCamera(void)
    {
        // Create the camera
        mCamera = mSceneMgr->createCamera("PlayerCam");
		
		SceneNode* camNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("mainCameraNode");
		camNode->attachObject(mCamera);
       //camNode->setPosition(Vector3(0,1,0));
        // Position it at 500 in Z direction
        //mCamera->setPosition(Vector3(0,0,500));
        // Look back along -Z
        //mCamera->lookAt(Vector3(0,0,-300));
        mCamera->setNearClipDistance(5);

    }
    
	void loadResources(void)
	{
		// Initialise, parse scripts etc
		ResourceGroupManager::getSingleton().initialiseResourceGroup("Bootstrap");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("General");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("PostProc");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Basic");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_EnvMap");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Caustic");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_MultiBounce_Shared");
		ResourceGroupManager::getSingleton().initialiseResourceGroup(resourceGroupName[currentMaterial]);
		if(currentMaterial == 2)
			ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_MultipleCausticRefraction");
		if(currentMaterial == 5)
			ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_MultipleCausticRefraction_MinMax");
	}
	Entity* object;

	void chooseSceneManager()
	{
		mSceneMgr = mRoot->createSceneManager("OctreeSceneManager");
		//mSceneMgr = mRoot->createSceneManager("OcclusionCullingSceneManager");
	}

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

	void createScene(void)
    {
		//createPostproc();

		OgreIlluminationManager::getSingleton().setMainCamera(mCamera);
		OgreIlluminationManager::getSingleton().setMainViewport(mWindow->getViewport(0));
		
		OgreIlluminationManager::getSingleton().setMaxJoinRadius(420);		

		Root::getSingleton()._setCurrentSceneManager(mSceneMgr);

		mCamera->setFOVy(Radian(Degree(90 * mWindow->getHeight() / mWindow->getWidth())));
		mCamera->setFarClipDistance(200);
		mCamera->setNearClipDistance(0.1);

		SceneNode* cn = mCamera->getParentSceneNode();

		OgreIlluminationManager::getSingleton().setFocusingSM(false);
	   OgreIlluminationManager::getSingleton().setShadowMapSize(700);
	   OgreIlluminationManager::getSingleton().setBlurShadowMap(true);
	   OgreIlluminationManager::getSingleton().setShadowMapMaterialName("GTP/Basic/Distance_Normalized");
	    mSceneMgr->setAmbientLight(ColourValue(0.505 * 0.2, 0.897 * 0.2, 0.914 * 0.2));
		
		capture  = new FrameCapture(mWindow);
		if(scene == 1) createScene1();
		if(scene == 2) createScene2();
	
		TexturePtr texPtr = Ogre::TextureManager::getSingleton().createManual(	"SCREENSHOT", 
																				"default",
																				TEX_TYPE_2D,
																				1600,
																				1200,
																				0,
																				0,
																				PF_R8G8B8,
																				TU_RENDERTARGET);
		screenTexture = texPtr.getPointer();
		RenderTexture* rt = screenTexture->getBuffer()->getRenderTarget();
		Viewport* vp = rt->addViewport(mCamera);
		rt->setAutoUpdated(false);
		vp->setOverlaysEnabled(false);
		

		OgreIlluminationManager::getSingleton().initTechniques();
	}
   void createScene1(void)
    {
     	SceneNode* rootNode = mSceneMgr->getRootSceneNode();
		
		mCamera->getParentSceneNode()->translate(0.944, 1.857, 1.054);
		//mCamera->lookAt(Vector3(0.11, 1.043, -0.102));
			
		object = mSceneMgr->createEntity("object", objectNames[currentObject]);
		 
		object->setMaterialName(materialNames[currentMaterial]);
		objectNode = rootNode->createChildSceneNode("objectNode");
		objectNode->attachObject(object);
		
		float scale = objectscales[currentObject] * scenescales[scene-1];
		objectNode->scale(scale, scale, scale);		
		
		objectNode->setPosition(0.136, 1.032, 0.031);
		objectNode->_updateBounds();

		capture->addAnimableNode(objectNode);
		capture->addAnimableNode(mCamera->getParentSceneNode());
		
		Entity* room = mSceneMgr->createEntity("scene", "difflab.mesh");
		//room->setMaterialName("GameTools/Phong");
		SceneNode* roomNode = rootNode->createChildSceneNode();
		roomNode->attachObject(room);		
		roomNode->_updateBounds();		

		mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
	
		Light* redLight1 = mSceneMgr->createLight("RedLight1");
		redLight1->setType(Light::LT_POINT);
		redLight1->setCastShadows(false);
        redLight1->setDiffuseColour(ColourValue(1,0.055, 0.0));
		redLight1->setPowerScale(1.6);
		SceneNode* redLightNode1 = rootNode->createChildSceneNode();
		redLightNode1->setPosition(0.05,2.361,-1.07);
		redLightNode1->attachObject(redLight1);

		Light* greenLight1 = mSceneMgr->createLight("GreenLight1");
		greenLight1->setType(Light::LT_POINT);
		greenLight1->setCastShadows(false);
        greenLight1->setDiffuseColour(ColourValue(0.362,0.783, 0.685));
		greenLight1->setPowerScale(2.0);
		SceneNode* greenLightNode1 = rootNode->createChildSceneNode();
		greenLightNode1->setPosition(1.312,1.313,0);
		greenLightNode1->attachObject(greenLight1); 

		Light* mainBlueLight = mSceneMgr->createLight("MainBlueLight");
		mainBlueLight->setType(Light::LT_SPOTLIGHT);
		mainBlueLight->setCastShadows(true);
        mainBlueLight->setDiffuseColour(ColourValue(0.395,0.766, 1.0));
		mainBlueLight->setPowerScale(3.0);
		mainBlueLight->setSpotlightRange(Degree(0),Degree(160));
		mainBlueLight->setAttenuation(2.5, 0, 1, 0);
		SceneNode* mainBlueLightNode = rootNode->createChildSceneNode();
		mainBlueLightNode->setPosition(-0.546,2.095,1.035);
		mainBlueLightNode->rotate(Vector3::UNIT_X, Degree(161.396));
		mainBlueLightNode->rotate(Vector3::UNIT_Y, Degree(53.955));
		mainBlueLightNode->rotate(Vector3::UNIT_Z, Degree(-145.065));
		mainBlueLight->setDirection(-1.5,-2.0,1.0);
		mainBlueLightNode->attachObject(mainBlueLight);

		Light* mainLight = mSceneMgr->createLight("MainLight");
		mainLight->setType(Light::LT_SPOTLIGHT);
		mainLight->setSpotlightRange(Degree(0),Degree(160));
		mainLight->setCastShadows(false);
        mainLight->setDiffuseColour(ColourValue(0.995,0.996, 0.80));
		mainLight->setPowerScale(1.0);
		mainLight->setAttenuation(3, 0, 1, 0);
		SceneNode* mainLightNode = rootNode->createChildSceneNode();
		mainLightNode->setPosition(0,2.5,0);
		mainLight->setDirection(0,-1.0,0);
		mainLightNode->attachObject(mainLight);

		/*
		BillboardSet* bbs = mSceneMgr->createBillboardSet("bb", 1);
		bbs->setDefaultDimensions(0.2, 0.2);
		bbs->createBillboard(Vector3::ZERO, ColourValue::White);
		bbs->setMaterialName("Flare");
		mainLightNode->attachObject(bbs);*/
   }
		
	void createScene2(void)
    {	   
     	SceneNode* rootNode = mSceneMgr->getRootSceneNode();
		
		//mCamera->getParentSceneNode()->translate(Vector3(6.564,4.328,0.059));
		//mCamera->setPosition(4.0,4.2,-3.5);
		//mCamera->getParentSceneNode()->translate(7.0,2.6,-0.5);
		mCamera->setPosition(7.0,2.6,-0.5);
		mCamera->lookAt(Vector3(1.0, 0.0,0.6));
		
		object = mSceneMgr->createEntity("object", objectNames[currentObject]);

		object->setMaterialName(materialNames[currentMaterial]);
		objectNode = rootNode->createChildSceneNode();
		objectNode->attachObject(object);

		float scale = objectscales[currentObject] * scenescales[scene-1];
		objectNode->scale(scale, scale, scale);
		
		objectNode->_updateBounds();

		Entity* room = mSceneMgr->createEntity("scene", "colorcube.mesh");
		//room->setMaterialName("GameTools/Phong");
		SceneNode* roomNode = rootNode->createChildSceneNode();
		roomNode->attachObject(room);
		roomNode->setScale(1,1,1);
		roomNode->_updateBounds();

		mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
		Light* Light1 = mSceneMgr->createLight("Light1");
		Light1->setType(Light::LT_SPOTLIGHT);
		Light1->setCastShadows(true);
        Light1->setDiffuseColour(ColourValue(1,1, 1));
		Light1->setPowerScale(1.0);
		SceneNode* LightNode1 = rootNode->createChildSceneNode();
		LightNode1->setPosition(3,3,3);
		Light1->setDirection(-1,-1,-1);
		Light1->setSpotlightRange(Degree(0),Degree(120));
		LightNode1->attachObject(Light1);
/*
		BillboardSet* bbs = mSceneMgr->createBillboardSet("bb", 1);
		bbs->setDefaultDimensions(0.2, 0.2);
		bbs->createBillboard(Vector3::ZERO, ColourValue::White);
		bbs->setMaterialName("Flare");
		LightNode1->attachObject(bbs);*/
   }

	void createFrameListener(void)
    {
		// This is where we instantiate our own frame listener
		mFrameListener= new RaytraceDemoListener(mWindow, mCamera, objectNode, object);
		mFrameListener->setPriority(1);
		OgreIlluminationManager::getSingleton().setPriority(3);
		capture->setPriority(2);
        mRoot->addFrameListener(capture);
		mRoot->addFrameListener(mFrameListener);
		mRoot->addFrameListener(&OgreIlluminationManager::getSingleton());

    }

};