#include <OgreMath.h>
#include <OgreIteratorWrappers.h>
#include <OgreRenderSystem.h>
#include <OgreCamera.h>
#include "OgreVisibilitySceneManager.h"
#include "OgreSceneNodeHierarchyInterface.h"
#include "OgreVisibilityOptionsManager.h"


namespace Ogre {

//-----------------------------------------------------------------------
VisibilitySceneManager::VisibilitySceneManager(GtpVisibility::VisibilityManager *visManager)
:mVisibilityManager(visManager), mUseVisibilityCulling(true), mShowVisualization(false)
{
	mHierarchyInterface = 
		new SceneNodeHierarchyInterface(this, mDestRenderSystem);
}
//-----------------------------------------------------------------------
VisibilitySceneManager::~VisibilitySceneManager()
{
	delete mHierarchyInterface;
}
//-----------------------------------------------------------------------
void VisibilitySceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters)
{
	mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
	// does nothing if hierarchical culling is used =>
	// we interleave identification and rendering of objects 
	// in _renderVisibibleObjects
	if (!mUseVisibilityCulling)
	{
		SceneManager::_findVisibleObjects(cam, onlyShadowCasters);
		return;	
	}
}
//-----------------------------------------------------------------------
void VisibilitySceneManager::_renderVisibleObjects()
{
	// two cameras (one for culling, one for rendering)
	mHierarchyInterface->InitFrame(mSceneRoot, mCameraInProgress);

	// call initframe to reset culling manager stats
	mVisibilityManager->GetCullingManager()->InitFrame();

	// standard terrain scenemanager rendering without hierarchical culling
	if (!mUseVisibilityCulling || mShowVisualization)
	{	
		SceneManager::_renderVisibleObjects();
		return;
	} 
	
	//-- hierarchical culling
	// the objects of different layers (e.g., background, scene, 
	// overlay) must be identified and rendered one after another

	//-- render background
	clearSpecialCaseRenderQueues();
	addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND);
	addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_EARLY);

	setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE);
	SceneManager::_renderVisibleObjects();

#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	_deleteRenderedQueueGroups();
#endif

	//-- render visible objects (i.e., all but overlay)
	clearSpecialCaseRenderQueues();
	addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY);
	setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);


	/** 
	* the hierarchical culling algorithm
	**/
	mVisibilityManager->ApplyVisibilityCulling();


#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	_deleteRenderedQueueGroups();
#endif

	//-- render overlay
	clearSpecialCaseRenderQueues();
	SceneManager::_renderVisibleObjects();

	//WriteLog(); // write out stats
}
//-----------------------------------------------------------------------
void VisibilitySceneManager::_updateSceneGraph(Camera* cam)
{
	mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
	mHierarchyInterface->SetRenderSystem(mDestRenderSystem);
	
	SceneManager::_updateSceneGraph(cam);
}
//-----------------------------------------------------------------------
bool VisibilitySceneManager::setOption(const String & key, const void * val)
{
	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
		setOption(key, val) || SceneManager::setOption(key, val);
}
//-----------------------------------------------------------------------
bool VisibilitySceneManager::getOption(const String & key, void *val)
{
	if (key == "NumHierarchyNodes")
	{
		* static_cast<unsigned int *>(val) = (unsigned int)mSceneNodes.size();
		return true;
	}
	
	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
		getOption(key, val) && SceneManager::getOption(key, val);
}
//-----------------------------------------------------------------------
bool VisibilitySceneManager::getOptionValues(const String & key, StringVector  &refValueList)
{
	return SceneManager::getOptionValues(key, refValueList);
}
//-----------------------------------------------------------------------
bool VisibilitySceneManager::getOptionKeys(StringVector & refKeys)
{
	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
		getOptionKeys(refKeys) || SceneManager::getOptionKeys(refKeys);
}
//-----------------------------------------------------------------------
void VisibilitySceneManager::setVisibilityManager(GtpVisibility::VisibilityManager *visManager)
{
	mVisibilityManager = visManager;
}
//-----------------------------------------------------------------------
GtpVisibility::VisibilityManager *VisibilitySceneManager::getVisibilityManager( void )
{
	return mVisibilityManager;
}

} // namespace Ogre