/**
    \file 
        TestCullingApplication.cpp
    \brief
        Tests the visibility culling algorithm
*/

#include <OgreNoMemoryMacros.h>
#include <CEGUI/CEGUI.h>
#include <../CEGUIRenderer/include/OgreCEGUIRenderer.h>
#include <../CEGUIRenderer/include/OgreCEGUIResourceProvider.h>
#include <../CEGUIRenderer/include/OgreCEGUITexture.h>
#include <OgreMemoryMacros.h>
#include <Ogre.h>
#include "TestCullingApplication.h"
#include "OgreSceneContentGenerator.h"

#define WIN32_LEAN_AND_MEAN
#include <windows.h>


/***********************************************/
/* TestCullingApplication implementation       */
/***********************************************/

//-----------------------------------------------------------------------
/*void TestCullingApplication::createCamera( void )
{
	// Create the camera
	mCamera = mSceneMgr->createCamera("CullCamera");

	// Position it at 500 in Z direction
	mCamera->setPosition(Vector3(128, 25, 128));

	// Look back along -Z
    mCamera->lookAt(Vector3(0, 0, -300));
    mCamera->setNearClipDistance(1);
    mCamera->setFarClipDistance(1000);
}*/
//-----------------------------------------------------------------------
TestCullingApplication::~TestCullingApplication()
{
	delete mSceneContentGenerator;
}
//-----------------------------------------------------------------------
void TestCullingApplication::createScene(void)
{
	// Set ambient light
	mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));
	
	// Create a light
	Light* l = mSceneMgr->createLight("MainLight");
	//l->setPosition(20,80,50);

	mSceneContentGenerator = new SceneContentGenerator(mSceneMgr);
	mSceneContentGenerator->GenerateScene(3000, "sphere.mesh");

	// Create a skybox
    mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox", 2000, true);
    ColourValue fadeColour(0.1, 0.1, 0.6);
	mWindow->getViewport(0)->setBackgroundColour(fadeColour);

	// CEGUI setup
	setupGui();
}
//-----------------------------------------------------------------------
void TestCullingApplication::setupGui()
{
	 mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, 
		 Ogre::RENDER_QUEUE_OVERLAY, false, 3000, ST_EXTERIOR_CLOSE);
     mGUISystem = new CEGUI::System(mGUIRenderer);

	 // Mouse
     CEGUI::SchemeManager::getSingleton().loadScheme((CEGUI::utf8*)"TaharezLook.scheme");
     CEGUI::MouseCursor::getSingleton().setImage("TaharezLook", "MouseArrow");
	 mGUISystem->setDefaultMouseCursor(
                (CEGUI::utf8*)"TaharezLook", (CEGUI::utf8*)"MouseArrow");

	 CEGUI::MouseCursor::getSingleton().show( );
}
//-----------------------------------------------------------------------
void TestCullingApplication::createFrameListener()
{
	mFrameListener= new TerrainFrameListener(mWindow, mCamera, mSceneMgr, 
		mGUIRenderer, mSceneContentGenerator);
	mFrameListener->showDebugOverlay(true);
	mRoot->addFrameListener(mFrameListener);
}
//-----------------------------------------------------------------------
void TestCullingApplication::chooseSceneManager(void)
{
    mSceneMgr = mRoot->getSceneManager(ST_GENERIC);
}


/*****************************************************/
/*       TerrainFrameListener implementation         */
/*****************************************************/
//-----------------------------------------------------------------------
TerrainFrameListener::TerrainFrameListener(RenderWindow* win, Camera* cam, 
									   SceneManager *sceneManager, 
									   CEGUI::Renderer *renderer,
									   SceneContentGenerator *sceneContentGenerator):
ExampleFrameListener(win, cam, false, true),
mSceneMgr(sceneManager),
mGUIRenderer(renderer), 
mShutdownRequested(false), 
mLMouseDown(false),
mRMouseDown(false),
mSceneContentGenerator(sceneContentGenerator),
mVisibilityThreshold(0),
mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING),
mShowOctree(false),
mUseDepthPass(false),
mTestGeometryForVisibleLeaves(true),
mShowVisualization(false),
mVisualizeCulledNodes(false)
{
    // Reduce move speed
	mMoveSpeed = 50;
	mRotateSpeed *= 2;
 
	// Register this so that we get mouse events.
	mEventProcessor->addMouseListener(this);
	mEventProcessor->addMouseMotionListener(this);
	mEventProcessor->addKeyListener(this);

	// show overlay
	Overlay* pOver = OverlayManager::getSingleton().getByName("Example/VisibilityDemoOverlay"); 

	mAlgorithmInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/AlgorithmInfo");
	mThresholdInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ThresholdInfo");
	
	mFrustumCulledNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/FrustumCulledNodesInfo");
	mQueryCulledNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/QueryCulledNodesInfo");
    mTraversedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/TraversedNodesInfo");
	mHierarchyNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/HierarchyNodesInfo");
	mRenderedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/RenderedNodesInfo");
	mObjectsCountInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ObjectsInfo");
	mTestGeometryForVisibleLeavesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/TestGeometryForVisibleLeavesInfo");
	mQueriesIssuedInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/QueriesIssuedInfo");
	

	mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]);
	mThresholdInfo->setCaption(": 0");
	mFrustumCulledNodesInfo->setCaption(": 0");
	mQueryCulledNodesInfo->setCaption(": 0");
	mTraversedNodesInfo->setCaption(": 0");
	mHierarchyNodesInfo->setCaption(": 0");
	mRenderedNodesInfo->setCaption(": 0");
	mObjectsCountInfo->setCaption(": 0");
	mTestGeometryForVisibleLeavesInfo->setCaption(": true");
	mQueriesIssuedInfo->setCaption(": 0");
	

	setAlgorithm(mCurrentAlgorithm);
	
	mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves);
	mSceneMgr->setOption("UseDepthPass", &mUseDepthPass);
	mSceneMgr->setOption("ShowVizualisation", &mShowVisualization);
	mSceneMgr->setOption("ShowOctree", &mShowOctree);

    pOver->show();
} 
//-----------------------------------------------------------------------
TerrainFrameListener::~TerrainFrameListener()
{
}
//-----------------------------------------------------------------------
void TerrainFrameListener::mouseMoved(MouseEvent *e)
{
	// Update CEGUI with the mouse motion
    CEGUI::System::getSingleton().injectMouseMove(e->getRelX() * 
		mGUIRenderer->getWidth(), e->getRelY() * mGUIRenderer->getHeight());
}
//-----------------------------------------------------------------------
void TerrainFrameListener::mousePressed(MouseEvent* e)
{
     // Left mouse button down
     if (e->getButtonID() & InputEvent::BUTTON0_MASK)
     {
		mLMouseDown = true; 
     }
     // Right mouse button down
     else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
     {
         CEGUI::MouseCursor::getSingleton().hide( );
         mRMouseDown = true;
     } // else if
} // mousePressed

 //-----------------------------------------------------------------------
void TerrainFrameListener::mouseReleased(MouseEvent* e)
{
    // Left mouse button up
    if (e->getButtonID() & InputEvent::BUTTON0_MASK)
    {
		CEGUI::MouseCursor::getSingleton().show();
        mLMouseDown = false;
    }
    // Right mouse button up
    else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
    {
        CEGUI::MouseCursor::getSingleton().show();
        mRMouseDown = false;
    }
} 
//-----------------------------------------------------------------------
void TerrainFrameListener::mouseDragged (MouseEvent *e)
 {
	 // If we are dragging the left mouse button.	 	 
	 if ( mLMouseDown )
     {
		
     }
	 // If we are dragging the right mouse button.
	 if ( mRMouseDown )
	 {
		 mCamera->yaw(-e->getRelX() * mRotateSpeed);
		 mCamera->pitch(-e->getRelY() * mRotateSpeed);
	 }
}
//-----------------------------------------------------------------------
bool TerrainFrameListener::frameStarted(const FrameEvent &evt)
{	 
	return ExampleFrameListener::frameStarted(evt);
}
//-----------------------------------------------------------------------
bool TerrainFrameListener::frameEnded(const FrameEvent& evt)
{
	if (mShutdownRequested)
		return false;

    if (timeDelay >= 0) 
        timeDelay -= evt.timeSinceLastFrame;

    KEY_PRESSED(KC_SPACE, 0.3, nextAlgorithm());

	KEY_PRESSED(KC_SUBTRACT, 0, changeThreshold(-10));
	KEY_PRESSED(KC_ADD, 0, changeThreshold(10));
	KEY_PRESSED(KC_O, 0.3, toggleTestGeometryForVisibleLeaves());
	KEY_PRESSED(KC_C, 0.3, toggleUseDepthPass());
	KEY_PRESSED(KC_V, 0.3, toggleShowViz());

	updateStats();

    return ExampleFrameListener::frameStarted(evt) && ExampleFrameListener::frameEnded(evt);        
}
//-----------------------------------------------------------------------
void TerrainFrameListener::changeThreshold(int incr)
{
	mVisibilityThreshold += incr; 
	if(mVisibilityThreshold < 0) mVisibilityThreshold = 0;
	
	char str[100]; sprintf(str,": %d", mVisibilityThreshold);

	mSceneMgr->setOption("Threshold", &mVisibilityThreshold); 
	mThresholdInfo->setCaption(str);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::nextAlgorithm()
{
	mCurrentAlgorithm = ++mCurrentAlgorithm % 
		GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS,

	setAlgorithm(mCurrentAlgorithm);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleTestGeometryForVisibleLeaves()
{
	mTestGeometryForVisibleLeaves = !mTestGeometryForVisibleLeaves;

	mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves);

	if(mTestGeometryForVisibleLeaves)
		mTestGeometryForVisibleLeavesInfo->setCaption(": true");
	else
		mTestGeometryForVisibleLeavesInfo->setCaption(": false");
}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleShowOctree()
{
	mShowOctree = !mShowOctree;

	mSceneMgr->setOption("ShowOctree", &mShowOctree);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleUseDepthPass()
{
	mUseDepthPass = !mUseDepthPass;

	mSceneMgr->setOption("UseDepthPass", &mUseDepthPass);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleShowViz()
{
	mShowVisualization = !mShowVisualization;

	mSceneMgr->setOption("PrepareVisualization", &mShowVisualization);
	mSceneMgr->setOption("VisualizeCulledNodes", &mVisualizeCulledNodes);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::setAlgorithm(int algorithm)
{
	mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]);
	mSceneMgr->setOption("Algorithm", &mCurrentAlgorithm);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::updateStats()
{
	unsigned int opt = 0;
	char str[100];
	
	mSceneMgr->getOption("NumFrustumCulledNodes", &opt); sprintf(str,": %d", opt); 
	mFrustumCulledNodesInfo->setCaption(str);
	
	mSceneMgr->getOption("NumQueriesIssued", &opt); sprintf(str,": %d", opt); 
	mQueriesIssuedInfo->setCaption(str);

	mSceneMgr->getOption("NumQueryCulledNodes", &opt); sprintf(str,": %d", opt); 
	mQueryCulledNodesInfo->setCaption(str);
	
	mSceneMgr->getOption("NumTraversedNodes", &opt); sprintf(str,": %d", opt); 
	mTraversedNodesInfo->setCaption(str);

	mSceneMgr->getOption("NumHierarchyNodes", &opt); sprintf(str,": %d", opt); 
	mHierarchyNodesInfo->setCaption(str);

	mSceneMgr->getOption("NumRenderedNodes", &opt); sprintf(str,": %d", opt); 
	mRenderedNodesInfo->setCaption(str);

	sprintf(str,": %d", mSceneContentGenerator->GetObjectCount()); 
	mObjectsCountInfo->setCaption(str);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::keyPressed(KeyEvent* e)
{
	if(e->getKey() == KC_ESCAPE)
    {
		mShutdownRequested = true;
		e->consume();
		return;
	}

	CEGUI::System::getSingleton().injectKeyDown(e->getKey());
	CEGUI::System::getSingleton().injectChar(e->getKeyChar());
	e->consume();
}
//-----------------------------------------------------------------------
void TerrainFrameListener::keyReleased(KeyEvent* e)
{
	CEGUI::System::getSingleton().injectKeyUp(e->getKey());
	e->consume();
}
//-----------------------------------------------------------------------
void TerrainFrameListener::keyClicked(KeyEvent* e) 
{
	// Do nothing
	e->consume();
}
//-----------------------------------------------------------------------
INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
{
    // Create application object
    TestCullingApplication app;

	try 
	{
        app.go();
    } 
	catch( Ogre::Exception& e ) 
	{
        MessageBox( NULL, e.getFullDescription().c_str(), "An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
    }	

    return 0;
}