#include "ExampleApplication.h"
#include "ExtendedCamera.h"
#include "Grass.h"
#include <vector>
#include <OgreVector3.h>
#include "LightComposite.h"
#include <OgreOSMScene.h>
#include <OgreConfigFile.h>

/**
	Callback handler to post-process created objects.
*/
class OSceneCallback : public OSMSceneCallbacks
{
	public:
		// We override the OnCreate method for cameras (See IXMLSceneCallbacks class)
		void OnCameraCreate(Ogre::Camera* pCamera, TiXmlElement* pCameraDesc) 
		{
			// If a camera of name "FirstCamera" is loaded, it will be set as the default current 
			if(pCamera->getName() == "FirstCamera")
				Ogre::Root::getSingleton().getAutoCreatedWindow()->getViewport(0)->setCamera(pCamera);
		}


};

class SampleListener : public ExampleFrameListener
{
protected:
	// References to the main character and the camera
	Character *mChar;
	ExtendedCamera *mExCamera;

	// Camera mode - Now supports 1st person, 3rd person (chasing) and 3rd person (fixed)
	unsigned int mMode;
	AnimationState* mCharacterAnimState;

public:

	SampleListener(RenderWindow* win, Camera* cam)
		: ExampleFrameListener(win, cam)
	{
		mChar = 0;
		mExCamera = 0;
		mMode = 0;
		mMoveSpeed = 1000;
	}

	void setCharacter (Character *character) {
		mChar = character;
		mCharacterAnimState = mChar->getEntity()->getAnimationState("Fly");
		mCharacterAnimState->setEnabled(true);
		mCharacterAnimState->setLoop(true);
	}

	void setExtendedCamera (ExtendedCamera *cam) {
		mExCamera = cam;
	}

	bool frameStarted(const FrameEvent& evt)
	{
		mInputDevice->capture ();

		if (mChar) {
			mChar->update (evt.timeSinceLastFrame, mInputDevice);

			if (mExCamera) {
				mExCamera->update (evt.timeSinceLastFrame, 
					mChar->getCameraNode ()->getWorldPosition (), 
					mChar->getSightNode ()->getWorldPosition ());

			}
		}

		mCharacterAnimState->addTime(evt.timeSinceLastFrame);

		// Exit if we press Esc
		if (mInputDevice->isKeyDown (KC_ESCAPE))
			return false;

		return true;
	}
};

class SkyPlaneListener : public ExampleFrameListener
{
protected:
	// References to the main character and the camera
	SceneManager *mSceneMgr;
	Grass *mGrass;
	LightComposite *mLightComposite;

	// Create the scene loader
	OSMScene* mOScene;

	// Camera mode - Now supports 1st person, 3rd person (chasing) and 3rd person (fixed)
	unsigned int mMode;
	AnimationState *mAnimState;

	// Gametools 8/11/2005 - Isma
	Real mAnimationSpeed;
	AnimationState* mCharacterAnimState;
	Real mFactorAnimationSpeed;
	Real mAngle;
	Real mStepAngle;

	unsigned int mFrame;
public:


	void loadScene(Ogre::String filename)
	{
		// Create an oE_Loader Callback object to post-process created objects
		OSceneCallback oeCallback;
		
		mOScene = new OSMScene(mSceneMgr, mWindow);

		// Initialises with the scene to be loaded and the callback if requiered
		mOScene->initialise(filename.c_str(), &oeCallback);

		// create and setup the scene in the root node
		mOScene->createScene();
	}

	SkyPlaneListener(RenderWindow* win, Camera* cam, SceneManager *sceneMgr)
		: ExampleFrameListener(win, cam)
	{
		//showDebugOverlay(false);
		mSceneMgr = sceneMgr;
		mMoveScale = 1;
		mRotScale = 0.025;
		mAngle = 0.0;
		mStepAngle = 10.0;

		Ogre::ConfigFile config;
		config.load("configScene.cfg");
		Ogre::String moveSpeed = config.getSetting("MoveSpeed");
		mMoveSpeed = Ogre::StringConverter::parseReal(moveSpeed);

		showDebugOverlay(false);
		//createCameraAutoTracking();	

		SceneNode *snButterfly = mSceneMgr->getSceneNode("butterflyNode");
		Entity *entityButterfly = (Entity*) snButterfly->getAttachedObject(0);
		mCharacterAnimState = entityButterfly->getAnimationState("Fly");
		mCharacterAnimState->setEnabled(true);
		mCharacterAnimState->setLoop(true);

		mFrame = 0;
		mFactorAnimationSpeed = 2.0;
		//mFactorAnimationSpeed = 0.1;
	}

	void createCameraAutoTracking()
	{
		SceneNode *cameraSceneNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("CamNode");
		cameraSceneNode->attachObject(mCamera);
		SceneNode *entitySceneNode = mSceneMgr->getSceneNode("butterflyNode");
		SceneNode *targetNode = mSceneMgr->getSceneNode("targetNode");
		//SceneNode *snLight = mSceneMgr->getSceneNode("lightNode");
		cameraSceneNode->setAutoTracking(true,targetNode);
		//cameraSceneNode->setAutoTracking(true,snLight);
		cameraSceneNode->translate(Vector3(300.0,0.0,0.0));
		// set up spline animation of node
		Animation* anim = mSceneMgr->createAnimation("CameraTrack",10);
		// Spline it for nice curves
		anim->setInterpolationMode(Animation::IM_SPLINE);
		// Create a track to animate the camera's node
		NodeAnimationTrack* track = anim->createNodeTrack(0, cameraSceneNode);
		//AnimationTrack* track = anim->createTrack(0, snLight);		
		// Setup keyframes
		TransformKeyFrame* key = track->createNodeKeyFrame(0); // startposition
		key->setTranslate(Vector3(0.0,0.0,300.0));
		key = track->createNodeKeyFrame(2.5);
		key->setTranslate(Vector3(-600.0,0.0,0.0));
		key = track->createNodeKeyFrame(5);
		key->setTranslate(Vector3(0.0,0.0,-600.0));
		key = track->createNodeKeyFrame(7.5);
		key->setTranslate(Vector3(600.0,0.0,0.0));	
		key = track->createNodeKeyFrame(10);
		key->setTranslate(Vector3(0.0,0.0,300.0));

		// Create a new animation state to track this
		mAnimState = mSceneMgr->createAnimationState("CameraTrack");
		mAnimState->setEnabled(true);
		mAnimState->setLoop(true);
	}

	void setGrass(Grass *grass)
	{
		mGrass = grass;
	}

	void setLightComposite(LightComposite *lightComposite)
	{
		loadScene("../../media/scene/scene.OSM");
		mLightComposite = lightComposite;
	}

	bool frameStarted(const FrameEvent& evt)
	{
		mLightComposite->update(mInputDevice);

		/*
		mAnimState->addTime(evt.timeSinceLastFrame * 0.5 * mFactorAnimationSpeed);
		//mGrass->waveGrass(evt.timeSinceLastFrame);
		//SceneNode *snLight = mSceneMgr->getSceneNode("bulletaLanternNode");
		SceneNode *snLight = mSceneMgr->getSceneNode("lightNode");		

		if (mInputDevice->isKeyDown(KC_I))
		{
			snLight->setPosition(snLight->getPosition() + Vector3(0.0,0.0,10.0));	
		}
		if (mInputDevice->isKeyDown(KC_K))
		{
			snLight->setPosition(snLight->getPosition() + Vector3(0.0,0.0,-10.0));	
		}
		if (mInputDevice->isKeyDown(KC_J))
		{
			snLight->translate(-10.0,0.0,0.0);			
		}
		if (mInputDevice->isKeyDown(KC_L))
		{
			snLight->translate(10.0,0.0,0.0);			
		}
		if (mInputDevice->isKeyDown(KC_U))
		{
			snLight->translate(0.0,10.0,0.0);
		}
		if (mInputDevice->isKeyDown(KC_O))
		{
			snLight->translate(0.0,-10.0,0.0);			
		}

		if ((mAngle < -45) && (mStepAngle < 0))
		{			
			mStepAngle = -mStepAngle;
		}
		if ((mAngle > 45) && (mStepAngle > 0))
		{
			mStepAngle = -mStepAngle;
		}
		mAngle = mAngle + mStepAngle;
		snLight->rotate(Vector3::UNIT_X,Radian(Degree(mStepAngle)));
		Real sunHeight;
		Real sunShift;
		SceneNode *snSun = mSceneMgr->getSceneNode("sunNode");
		sunHeight = -mAngle * 20.0;
		sunShift = -mAngle * 400.0;
		snSun->setPosition(0.0,2000.0,0.0);
		snSun->translate(0.0,sunHeight,sunShift);
		//LogManager::getSingleton().logMessage("sunHeight:" + StringConverter::toString(sunHeight));

		//ColourValue newColour;
		//Real intensity;
		//intensity = 1.0 - (Math::Abs(mAngle) + 45.0) / 90.0;
		//newColour.r = mLightComposite->getNightLight().r + (mLightComposite->getRangeLight().r * intensity);
		//newColour.g = mLightComposite->getNightLight().g + (mLightComposite->getRangeLight().g * intensity);
		//newColour.b = mLightComposite->getNightLight().b + (mLightComposite->getRangeLight().b * intensity);
		//mLightComposite->setAmbientColour(newColour);

		Light *light = mLightComposite->getLight(0);

		//ColourValue newDiffuseColour;
		//ColourValue diffuseDarkColour(0.0,0.0,0.0);
		//ColourValue diffuseBrightColour(0.7,0.8,1.0);
		//ColourValue diffuseRange = diffuseBrightColour - diffuseDarkColour;
		//newDiffuseColour.r = diffuseDarkColour.r + (diffuseRange.r * intensity);
		//newDiffuseColour.g = diffuseDarkColour.g + (diffuseRange.g * intensity);
		//newDiffuseColour.b = diffuseDarkColour.b + (diffuseRange.b * intensity);
		light->setDiffuseColour(ColourValue(1.0,1.0,1.0));
		light->setSpecularColour(ColourValue(1.0,1.0,1.0));

		Vector3 dir=Vector3(snSun->getPosition());
		dir.normalise();
		light->setDirection(dir);
		LogManager::getSingleton().logMessage("LightDirection:" + StringConverter::toString(light->getDirection()));

		GpuProgramParametersSharedPtr vertParams,fragParams;
		MaterialPtr mat = MaterialManager::getSingleton().getByName("chestnutLeavesBillboardCloudGroupMaterial0");
		vertParams = mat->getBestTechnique()->getPass(0)->getVertexProgramParameters();
		//vertParams->setNamedConstant("lightDirection",dir);
		fragParams = mat->getBestTechnique()->getPass(0)->getFragmentProgramParameters();
		//fragParams->setNamedConstant("Kd",intensity);

		//ColourValue newShadowColour;
		//ColourValue darkShadow(0.4,0.4,0.4);
		//ColourValue lightShadow(0.8,0.8,0.8);
		//ColourValue shadowRange = lightShadow - darkShadow;
		//newShadowColour.r = darkShadow.r + (shadowRange.r * intensity);
		//newShadowColour.g = darkShadow.g + (shadowRange.g * intensity);
		//newShadowColour.b = darkShadow.b + (shadowRange.b * intensity);
		//mLightComposite->setShadowColour(newShadowColour);

		//BillboardSet *bbs = mSceneMgr->getBillboardSet("lightbbs");
		//bbs->getBillboard(0)->setColour(newColour);

		// Gametools 8/11/2005 - Isma
		// When recording....
		//mAnimationSpeed = Math::RangeRandom(0.25*evt.timeSinceLastFrame,0.5*evt.timeSinceLastFrame);
		mAnimationSpeed = Math::RangeRandom(evt.timeSinceLastFrame*1000.0,evt.timeSinceLastFrame*1200.0);
		
		//mLightComposite->showDebugShadowMap(0);
		*/
		SceneNode *butterflyNode = mSceneMgr->getSceneNode("butterflyNode");
		Entity* butterfly = (Entity*)butterflyNode->getAttachedObject(0);
		Ogre::AnimationState* characterAnimState = butterfly ->getAnimationState("Fly");
		characterAnimState->setEnabled(true);
		characterAnimState->setLoop(true);
		characterAnimState->addTime(evt.timeSinceLastFrame);


		static Ogre::Real currentTime = 0;

		// We update all loaded animations each frame
		Ogre::SceneManager::AnimationIterator animationIt = mSceneMgr->getAnimationIterator();

		while(animationIt.hasMoreElements()) 
		{
			Ogre::Animation* animation = animationIt.getNext();
			
			const Ogre::Animation::NodeTrackList& trackList = animation->_getNodeTrackList();
			
			Ogre::Animation::NodeTrackList::const_iterator it = trackList.begin();
			Ogre::Animation::NodeTrackList::const_iterator iend = trackList.end();

			for(; it != iend; ++it) {
				const Ogre::NodeAnimationTrack* track = it->second;
				track->getAssociatedNode()->resetToInitialState();
			}
			
			currentTime += evt.timeSinceLastFrame;
			animation->apply(currentTime);
		}		

		return ExampleFrameListener::frameStarted(evt);
	}

	bool frameEnded(const FrameEvent& evt)
	{
		return ExampleFrameListener::frameEnded(evt);
	}
};

class SkyPlaneApplication : public ExampleApplication
{
public:
	std::vector<Vector3> vVertexs;

	SkyPlaneApplication() 
	{
	}




protected:

	// Gametools 8/11/2005
	// Main character
	OgreCharacter *ogre;
	ExtendedCamera *exCamera;
	Grass *mGrass;
	LightComposite *mLightComposite;
	Ogre::ConfigFile config;
	Ogre::String mNumTrees;

	// Just override the mandatory create scene method
	void createScene(void)
	{
		
		config.load("configScene.cfg");
		mNumTrees = config.getSetting("NumTrees");

		SceneManager *mSceneMgr = Root::getSingleton().getSceneManager("ExampleSMInstance");

		ColourValue nightLight(0.09,0.07,0.27);
		ColourValue dayLight(1.0,1.0,1.0);
		//ColourValue dayLight(0.85,0.88,0.96);
		ColourValue shadow(0.6,0.6,0.6,1.0);
		mLightComposite = new LightComposite();
		//mLightComposite->setDayLight(nightLight);
		mLightComposite->setDayLight(dayLight);
		mLightComposite->setNightLight(nightLight);
		mLightComposite->init(mSceneMgr,mCamera);
		mLightComposite->setShadowTexturePixelFormat(PF_A8R8G8B8);
		// ATI
		// Seems that NVIDIA don't support at all 16 bits FLOAT RGBA textures...!
		//mLightComposite->setShadowTexturePixelFormat(PF_FLOAT16_RGBA);
		// NVIDIA
		//mLightComposite->setShadowTexturePixelFormat(PF_FLOAT32_RGBA);
		mLightComposite->setShadowTextureSize(1024);
		//mLightComposite->setShadowTextureSize(2048);
		mLightComposite->setShadowColour(shadow);
		//mLightComposite->setAmbientColour(nightLight);
		mLightComposite->setAmbientColour(dayLight);
		mLightComposite->showShadowMapOverlay(false);
		mLightComposite->createShadowMapOverlay(0);	

		//mLightComposite->setDayLight(Vector3(1.0,1.0,1.0));
		//mLightComposite->setNightLight(Vector3(0.0,0.0,0.0));

		//// Define the required skyplane
		//Plane skyPlane;
		//// 5000 world units from the camera
		//skyPlane.d = 5000;
		//// Above the camera, facing down
		//skyPlane.normal = -Vector3::UNIT_Y;
		//// Create the plane 10000 units wide, tile the texture 3 times
		//mSceneMgr->setSkyPlane(true, skyPlane,"Examples/SpaceSkyPlaneNight",150000,500);

		mSceneMgr->setSkyBox(true, "CloudsSkyBox");

		// Floor plane
		Plane plane;
		plane.normal = Vector3::UNIT_Y;
		plane.d = 100;
		MeshManager::getSingleton().createPlane("Ground", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane, 
			15000, 15000, 200, 200, true, 1, 60, 60, Vector3::UNIT_Z);
		Entity* pPlaneEnt = mSceneMgr->createEntity("Ground", "Ground");
		pPlaneEnt->setMaterialName("Examples/GrassFloor");
		pPlaneEnt->setCastShadows(false);

		SceneNode *terrain = mSceneMgr->getRootSceneNode()->createChildSceneNode();
		terrain->attachObject(pPlaneEnt);
		terrain->setPosition(Vector3(0.0,0.0,0.0));

		SceneNode *forestNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("forestNode");

		for (unsigned int i = 0; i < Ogre::StringConverter::parseInt(mNumTrees); i++)
		{
			Real xPos = Math::RangeRandom(-5000.0, 5000.0);
			Real zPos = Math::RangeRandom(-5000.0, 5000.0);

			if (i == 0)
			{
				xPos = 200;
				zPos = 0;
			}
			else if (i == 1)
			{
				xPos = -200;
				zPos = 0;
			}			

			if ((i == 0) || (i == 1) || !(((xPos < 1000) && (xPos > -2000)) && ((zPos < 1000) && (zPos > -2000))))
			{				
				Entity *leaves = mSceneMgr->createEntity("leavesNode_" + StringConverter::toString(i),"chestnutLeavesVisibilityBillboardCloudGroupedIndirectTexturingLOD02.mesh");
				leaves->setCastShadows(true);				
				SceneNode *leavesNode = forestNode->createChildSceneNode();
				leavesNode->setPosition(xPos,120.0,zPos);
				leavesNode->attachObject(leaves);
				leavesNode->scale(4.0,4.0,4.0);		
				leaves->setNormaliseNormals(true);

				SceneNode *trunkNode;
				Entity* trunk;
				trunk = mSceneMgr->createEntity("head1_" + StringConverter::toString(i), "chestnutTrunkLevel2.mesh");
				trunkNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("trunkNode_" + StringConverter::toString(i));
				trunkNode->attachObject(trunk);				
				trunkNode->setPosition(xPos,120.0,zPos);
				trunkNode->scale(4.0,4.0,4.0);
				trunk->setNormaliseNormals(true);
			}
		}

		StaticGeometry* s = mSceneMgr->createStaticGeometry("forestStatic");
		s->setRegionDimensions(Vector3(1000, 1000, 1000));
		s->setOrigin(Vector3(-500, 500, 500));
		s->addSceneNode(forestNode);
		s->build();
		forestNode->setVisible(false, true);
		s->setCastShadows(true);
		s->setVisible(true);

		// Point light, movable, reddish
		//ColourValue mMinLightColour(0.7, 0.9, 0.4);
		//ColourValue mMaxLightColour(0.8, 0.9, 0.4);
		//Real mMinFlareSize = 400;
		//Real mMaxFlareSize = 500;
		//Light *mLight = mSceneMgr->createLight("Light2");
		//mLight->setType(Light::LT_DIRECTIONAL);
		//mLight->setDirection(Vector3(-0.5, -1.0, 0.5));
		//mLight->setCastShadows(true);
		//mLight->setDiffuseColour(1.0, 1.0, 1.0);	
		//mLight->setSpecularColour(1.0, 1.0, 1.0);

		//SceneNode *lightNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("lightNode");
		//lightNode->attachObject(mLight);
		//mLightComposite->addLight(mLight);
		//mLightComposite->setCurrentLight(0);

		//SceneNode *sunNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("sunNode");
		//BillboardSet* bbsSun = mSceneMgr->createBillboardSet("lightbbs", 1);
		//bbsSun->setMaterialName("Examples/Flare");
		//Billboard* bb = bbsSun->createBillboard(0,0,0,dayLight);
		//bb->setDimensions(1500.0,1500.0);
		//sunNode->attachObject(bbsSun);

		//lightNode->setDirection(Vector3::UNIT_Z);
		//lightNode->setPosition(Vector3(186.65,561.971,216.371));

		Entity *entityRuinMesh = mSceneMgr->createEntity("ruin","ruin.mesh");
		entityRuinMesh->setCastShadows(true);
		SceneNode *snRuinMesh = mSceneMgr->getRootSceneNode()->createChildSceneNode();
		snRuinMesh->attachObject(entityRuinMesh);		
		snRuinMesh->translate(0,-110.0,105.0+150.0);
		snRuinMesh->scale(2.0,2.0,2.0);

		Entity *barrel = mSceneMgr->createEntity("barrel","barrel.mesh");
		SceneNode *barrelNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("barrelNode");
		barrelNode->attachObject(barrel);
		barrelNode->translate(225.0,-20.0,185.0);
		barrelNode->scale(0.75,0.75,0.75);
		barrelNode->rotate(Vector3::UNIT_X,Radian(Degree(90.0)));
		barrel->setCastShadows(true);
		barrel->setNormaliseNormals(true);

		Entity *butterfly = mSceneMgr->createEntity("butterfly", "butterfly_bones_animated.mesh");
		SceneNode *butterflyNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("butterflyNode");
		butterflyNode->setPosition(Vector3(0.0,200.0,3000.0));
		butterflyNode->attachObject(butterfly);
		butterflyNode->setPosition(Vector3(-82.5,-45.1,35.0+150.0));
		butterflyNode->scale(1.0/2.0,1.0/2.0,1.0/2.0);
		butterfly->setCastShadows(true);
		butterfly->setNormaliseNormals(true);

		SceneNode *farmNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("farmNode");
		Entity *farm = mSceneMgr->createEntity("farm","farm.mesh");
		farm->setCastShadows(true);
		farm->setNormaliseNormals(true);

		Entity *cow = mSceneMgr->createEntity("cow","cow.mesh");
		cow->setCastShadows(true);
		farmNode->attachObject(farm);
		SceneNode *cowNode = farmNode->createChildSceneNode("cowNode");
		cowNode->attachObject(cow);
		cowNode->translate(Vector3(-9.1,7,3.5));
		farmNode->scale(Vector3(150,150,150));
		Vector3 positionFarm = Vector3(0.0,200.0,-2200);
		farmNode->setPosition(positionFarm);

		mCamera->setFOVy(Radian(Degree(60.0)));	
		mCamera->setPosition(Vector3(44.8621, -2.74644, 282.558));
		mCamera->setOrientation(Quaternion(0.9296, 0.09672, 0.345428, -0.05414));

		mGrass = new Grass();
		mGrass->setGrassShadowReceiver(false);
		mGrass->setGrassScaleRandomRangeMax(Vector3(1.0,1.0,1.0));
		mGrass->setGrassScaleRandomRangeMin(Vector3(1.0,0.75,1.0));
		mGrass->setGrassHeight(50.0);
		mGrass->setGrassWidth(40.0);
		mGrass->setGrassFrequency(30);
		mGrass->setGrassInterFrequency(20);
		mGrass->setGrassMaterial("Examples/GrassBlades");
		mGrass->setGrassMeshName("grassblades");
		mGrass->setSceneManager(mSceneMgr);
		mGrass->setGrassHeightPosition(-100);
		mGrass->setGrassLandscapeSizeX(4000);
		mGrass->setGrassLandscapeSizeZ(4000);
		mGrass->initGrass();

		SceneNode *targetNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("targetNode");
		targetNode->setPosition(Vector3(0.0,0.0,0.0));
		SceneNode *targetNodeFrontTrees = mSceneMgr->getRootSceneNode()->createChildSceneNode("targetNodeFrontTrees");
		targetNodeFrontTrees->setPosition(Vector3(0.0,0.0,200.0));

		////// Main character
		//OgreCharacter *ogre = new OgreCharacter ("Character", mSceneMgr);
		//ExtendedCamera *exCamera = new ExtendedCamera ("ExtendedCamera", mSceneMgr, mCamera);

		//mFrameListener = new SampleListener (mWindow, mCamera);
		//static_cast<SampleListener *>(mFrameListener)->setCharacter (ogre);
		//static_cast<SampleListener *>(mFrameListener)->setExtendedCamera (exCamera);
	}

	//  // Create new frame listener
	  void createFrameListener(void)
	  {
	      mFrameListener= new SkyPlaneListener(mWindow, mCamera, mSceneMgr);
	static_cast<SkyPlaneListener *>(mFrameListener)->setGrass(mGrass);

	static_cast<SkyPlaneListener *>(mFrameListener)->setLightComposite(mLightComposite);		
	      mRoot->addFrameListener(mFrameListener);
	  }

	//void createFrameListener(void)
	//{
	//	mRoot->addFrameListener(mFrameListener);
	//}

};