/*
-----------------------------------------------------------------------------
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 "FPSPlayer.h"

AnimationState* mAnimState = 0;
bool cullCamera = true;
Body *throwSphere = 0;
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;
// Listener class for frame updates
class MoriaDemoFrameListener : public ExampleFrameListener
{
protected:
	
	unsigned long framecount;
	SceneNode* mainLightNode;
	Light* light;
	SceneNode* sysNode;
	
public:
    MoriaDemoFrameListener(RenderWindow* window, Camera* maincam, SceneNode* lightNode, Light* l, SceneNode* sysNode)
        :ExampleFrameListener(window, maincam) 
				 
    {
		mainLightNode = lightNode;
		light = l;
		framecount = 0;	
		mMoveSpeed /= 50.0;
		this->sysNode = sysNode;

		mStatsOn = false;
		showDebugOverlay(mStatsOn);

    }

    bool frameStarted(const FrameEvent& evt)
    {	
		float thisTime = (float) Root::getSingleton().getTimer()->getMilliseconds() / 2000.0f;
		thisTime= 0;
		//mainLightNode->setPosition(Vector3(2*cos(thisTime), 2, 2 * sin(thisTime)) + Vector3(5, 0, 5));
		Vector3 pos = light->getDerivedPosition();
		pos.normalise();
		pos *= -1;
		//light->setDirection( pos);
		
		framecount++;
	  
//	    mAnimState->addTime(evt.timeSinceLastFrame * 1.0);  
		

		//sysNode->setPosition(mCamera->getPosition() - Vector3(0,1.5,0));
		//sysNode->setPosition(FPSPlayer::thePlayer->getPosition() - Vector3(0,1.5,0));

        return ExampleFrameListener::frameStarted(evt);     
    }

	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;
			light->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/Moria/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/Moria/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/Moria/PostProc/GlowBlurH").getPointer();
			m->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("Stretch", glowStrech);
			m = (Ogre::Material*) MaterialManager::getSingleton().getByName("GTP/Moria/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/Moria/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/Moria/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_I))
		{
			light->getParentSceneNode()->setPosition(
				light->getParentSceneNode()->getPosition()
				+ Vector3(0.2,0,0));
		}
		if (mInputDevice->isKeyDown(KC_K))
		{
			light->getParentSceneNode()->setPosition(
				light->getParentSceneNode()->getPosition()
				+ Vector3(-0.2,0,0));
		}
		if (mInputDevice->isKeyDown(KC_J))
		{
			light->getParentSceneNode()->setPosition(
				light->getParentSceneNode()->getPosition()
				+ Vector3(0,0,0.2));
		}
		if (mInputDevice->isKeyDown(KC_L))
		{
			light->getParentSceneNode()->setPosition(
				light->getParentSceneNode()->getPosition()
				+ Vector3(0,0,-0.2));
		}
		
	
		
	//	return ExampleFrameListener::processUnbufferedKeyInput(evt);

		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;
	}

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

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




protected:
	SceneNode* kupolaNode;
	SceneNode* mainLightNode;
	Light* mainLight;
	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("PostProc");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Particles");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_PathMap");
		ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Moria");		
		//ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Caustic");
	}

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

		CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0),
														"GTP/Moria/PostProc/Glow");
		CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
														"GTP/Moria/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
    {
		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(128);
	   OgreIlluminationManager::getSingleton().setBlurShadowMap(true);
	   OgreIlluminationManager::getSingleton().setShadowMapMaterialName(Light::LT_SPOTLIGHT, "GTP/Basic/Distance_Normalized");//GameTools/ShadowMapDistance
	   OgreIlluminationManager::getSingleton().setShadowMapMaterialName(Light::LT_POINT, "GTP/Basic/Distance_Normalized");
	   OgreIlluminationManager::getSingleton().setUseLISPSM(false);
	   OgreIlluminationManager::getSingleton().joinSharedRuns(false);
				
		Root::getSingleton()._setCurrentSceneManager(mSceneMgr);
		//mCamera->setPosition(-20,3,0);
		//mCamera->setPosition(0,100,0);
		//mCamera->lookAt(0,-1,0);
		mCamera->setFOVy(Radian(Degree(80)));
		mCamera->setNearClipDistance(0.001);
		mCamera->setFarClipDistance(150);
		// 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("moria.level");	//towers2.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("prmEntryPoints.text");

		NXScene->createActor("FakeFloor", new CubeShape(140,2,60), Vector3(0,-1,0), "static: yes"); 
		NXScene->createActor("FakeCeiling", new CubeShape(140,2,60), Vector3(0,17,0), "static: yes"); 
		NXScene->createActor("Wall1", new CubeShape(140,16,2), Vector3(0,8,30), "static: yes"); 
		NXScene->createActor("Wall2", new CubeShape(140,16,2), Vector3(0,8,-30), "static: yes"); 
		NXScene->createActor("Wall3", new CubeShape(2,16,60), Vector3(70,8,0), "static: yes"); 
		NXScene->createActor("Wall4", new CubeShape(2,16,60), Vector3(-70,8,0), "static: yes"); 
/*
	   ParticleSystem* pSys1 = mSceneMgr->createParticleSystem("psys1", "GTP/Moria/Smoke_Large");
	   pSys1->setKeepParticlesInLocalSpace(false);
	   SceneNode *pSysNode = rootNode->createChildSceneNode("psys1");
	   pSysNode->attachObject(pSys1);
	   pSysNode->setPosition(-40,-1,-15);*/
	
		mainLight = mSceneMgr->createLight("MainLight");
		mainLight->setType(Light::LT_POINT);
		mainLight->setCastShadows(true);
        mainLight->setDiffuseColour(ColourValue::White);
		mainLight->setSpecularColour(ColourValue::White);
		mainLightNode = rootNode->createChildSceneNode();
		
		mainLightNode->setPosition(15,5,15);		
		mainLight->setPowerScale(165);
		//mainLight->setDirection(1,0, 0);
		mainLightNode->attachObject(mainLight);
		//mainLight->setSpotlightRange(Degree(0),Degree(120));
		mainLight->setAttenuation(200.0, 0, 0, 3);
	
		Vector4 v = mainLight->getAs4DVector();

		BillboardSet* bbs = mSceneMgr->createBillboardSet("bb", 1);
		bbs->setDefaultDimensions(0.3, 0.3);
		bbs->createBillboard(Vector3::ZERO, ColourValue::White);
		bbs->setMaterialName("Flare");
		mainLightNode->attachObject(bbs);

		/*    Entity* ent = mSceneMgr->createEntity("troll", "troll.mesh");
			ent->setCastShadows(true);
            // Add entity to the scene node
            SceneNode *trollNode = mSceneMgr->getRootSceneNode()->createChildSceneNode( Vector3(5,0,5));
			trollNode->attachObject(ent);
			trollNode->setScale(0.05,0.05,0.05);
            mAnimState = ent->getAnimationState("stand");
            mAnimState->setEnabled(true);*/

		PlayerCharacter::frameListenerPriority = 20;
	
		gFPSPlayer = new FPSPlayer(NXScene, mSceneMgr, Vector3(0.5, 1.8, 0.3), Vector3(5, 10, 15), 1.6, 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("trollLOD.mesh", 0.05, false);
		troll->addWeaponModel("trollMace.mesh", "RightHand");

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

/*
		TrollCharacter* troll2 = new TrollCharacter("troll2", NXScene, mSceneMgr, Vector3(1.5, 3.0, 1.2), Vector3(25, 10, 15), false);
		troll2->addPlayerMesh("troll.mesh", 0.05, false);
		troll2->addWeaponModel("trollMace.mesh", "RightHand");

		TrollCharacter* troll3 = new TrollCharacter("troll3", NXScene, mSceneMgr, Vector3(1.5, 3.0, 1.2), Vector3(35, 10, 15), false);
		troll3->addPlayerMesh("troll.mesh", 0.05, false);
		troll3->addWeaponModel("trollMace.mesh", "RightHand");
*/
		
		/*for(float i = 0; i< 7; i++)
		{
			float size = 0.5;
			ActorParams ac;
			ac.setToDefault();
			ac.mass = 1.0;
			ac.nodescale = size;
			Body* b = NXScene->createBody("cube.mesh",
								new CubeShape(size, size, size),
								Vector3(3,size/2.0 + i * 5.0,3),
								ac);
			b->setCharacterCollisionGroup(NX_CHARACTER_COL_GROUP_PUSHABLE);
			
		}*/
		
	
	 /*  ParticleSystem* pSys1 = mSceneMgr->createParticleSystem("psys1", "MoriaDust");
	   pSys1->setKeepParticlesInLocalSpace(true);
	   pSysNode = rootNode->createChildSceneNode("psys1");
	   pSysNode->attachObject(pSys1);
	   pSysNode->setPosition(0,0,0);*/

	//	LightList LL;
	//	mSceneMgr->_populateLightList(Vector3(0,0,0), 200, LL);
	//	int numlights = LL.size();

		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 MoriaDemoFrameListener(mWindow,
			mCamera, mainLightNode, mainLight, pSysNode	);
        mFrameListener->setPriority(10);	
		mRoot->addFrameListener(mFrameListener);
//		gFPSPlayer->setPriority(20);
//		mRoot->addFrameListener(gFPSPlayer);
		OgreIlluminationManager::getSingleton().setPriority(100);
	    mRoot->addFrameListener(&OgreIlluminationManager::getSingleton());
	  
    }

};