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

#include <windows.h>

namespace Ogre {

//-----------------------------------------------------------------------
VisibilityOctreeSceneManager::VisibilityOctreeSceneManager(
	GtpVisibility::VisibilityManager *visManager)
: mVisibilityManager(visManager), mUseCulling(true)
{
	mHierarchyInterface = 
		new OctreeHierarchyInterface(this, mDestRenderSystem);
	//visManager->SetCullingManager(GtpVisibility::VisibilityEnvironment::STOP_AND_WAIT_CULLING);
	
	//mDisplayNodes = true;
	//mShowBoundingBoxes = true;
	//mShowBoxes = true;

	mMaxDepth = 20;
}
//-----------------------------------------------------------------------
VisibilityOctreeSceneManager::~VisibilityOctreeSceneManager()
{
	delete mHierarchyInterface;
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::_renderVisibleObjects()
{
	mHierarchyInterface->InitFrame(mOctree, mCameraInProgress);
	mVisibilityManager->GetCullingManager()->InitFrame();

	if(!mUseCulling)
	{	
		OctreeSceneManager::_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 remaining objects, e.g., overlay
	clearSpecialCaseRenderQueues();
	SceneManager::_renderVisibleObjects();
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters)
{
	// empty if hierarchical culling is used =>
	// we interleave identification and rendering of objects 
	// in _renderVisibibleObjects 
	if(!mUseCulling)
	{
		OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
	}
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::_updateSceneGraph(Camera* cam)
{
	mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
	mHierarchyInterface->SetRenderSystem(mDestRenderSystem);

#ifdef GTP_VISIBILITY_MODIFIED_OGRE
    mHierarchyInterface->SetNumOctreeNodes(mNumOctreeNodes);
#endif
	OctreeSceneManager::_updateSceneGraph(cam);
}
//-----------------------------------------------------------------------
bool VisibilityOctreeSceneManager::setOption(const String & key, const void * val)
{
	if (key == "UseCulling")
	{
		mUseCulling = (*static_cast<const bool *>(val));
		return true;
	}

	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
		setOption(key, val) || OctreeSceneManager::setOption(key, val);
}
//-----------------------------------------------------------------------
bool VisibilityOctreeSceneManager::getOption(const String & key, void *val)
{
	if (key == "NumHierarchyNodes")
	{
		* static_cast<unsigned int *>(val) = (unsigned int)mNumOctreeNodes;
		return true;
	}

	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
		getOption(key, val) && OctreeSceneManager::getOption(key, val);
}
//-----------------------------------------------------------------------
bool VisibilityOctreeSceneManager::getOptionValues(const String & key, StringVector  &refValueList)
{
	return OctreeSceneManager::getOptionValues( key, refValueList );
}
//-----------------------------------------------------------------------
bool VisibilityOctreeSceneManager::getOptionKeys(StringVector & refKeys)
{
	return  VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
		getOptionKeys ( refKeys ) || OctreeSceneManager::getOptionKeys(refKeys);
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::setVisibilityManager(GtpVisibility::VisibilityManager *visManager)
{
    mVisibilityManager = visManager;
}
//-----------------------------------------------------------------------
GtpVisibility::VisibilityManager *VisibilityOctreeSceneManager::getVisibilityManager()
{
	return mVisibilityManager;
}

}   // namespace Ogre