#include "OgreOctreeHierarchyInterface.h"
#include <OgreOctree.h>
#include <OgreLogManager.h>
#include <OgreStringConverter.h>


namespace Ogre {

//-----------------------------------------------------------------------
OctreeHierarchyInterface::OctreeHierarchyInterface(OctreeSceneManager *sm, 
												   RenderSystem *rsys): 
SceneNodeHierarchyInterface(sm, rsys)
{}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node)
{
	++ mNumTraversedNodes;

	Octree *octree = static_cast<Octree *>(node);

	// if we come across some renderable geometry => render it
	if (!octree->mNodes.empty())
	{
		RenderNode(node);
	}
	
	
	// if not all subtrees are empty
	if (!IsLeaf(node))
	{
		Octree *nextChild;

		if ((nextChild = octree->mChildren[0][0][0]) != NULL)
			mDistanceQueue->push(nextChild);
		if ((nextChild = octree->mChildren[0][0][1]) != NULL)
			mDistanceQueue->push(nextChild);
		if ((nextChild = octree->mChildren[0][1][0]) != NULL)
			mDistanceQueue->push(nextChild);
		if ((nextChild = octree->mChildren[0][1][1]) != NULL)
           	mDistanceQueue->push(nextChild);
		if ((nextChild = octree->mChildren[1][0][0]) != NULL)
			mDistanceQueue->push(nextChild);
		if ((nextChild = octree->mChildren[1][0][1]) != NULL)
			mDistanceQueue->push(nextChild);
		if ((nextChild = octree->mChildren[1][1][0]) != NULL)
			mDistanceQueue->push(nextChild);
		if ((nextChild = octree->mChildren[1][1][1]) != NULL)
			mDistanceQueue->push(nextChild);
	}
}
//-----------------------------------------------------------------------
GtpVisibility::HierarchyNode *OctreeHierarchyInterface::GetRandomLeaf(GtpVisibility::HierarchyNode *root) 
{ 
	if (IsLeaf(root))
		return root;

	Octree *octree = static_cast<Octree *>(root);

	// random decision
	Octree *child = NULL;
	
	std::vector<Octree *> nodes;
	nodes.reserve(8);

	for (int i = 0; i < 8; ++ i)
	{
		int x = (i & 4) / 4;
		int y = (i & 2) / 2;
		int z = i & 1;
	
		if ((child = octree->mChildren[x][y][z]) != NULL)
		{
			nodes.push_back(child);
		}
	}

	if (nodes.empty())
		return NULL;

	int r = (int)(((float)rand() / RAND_MAX) * ((float)nodes.size() - 0.5f));

	return GetRandomLeaf(nodes[r]);
}
//-----------------------------------------------------------------------
bool OctreeHierarchyInterface::IsLeaf(GtpVisibility::HierarchyNode *node) const
{
	Octree *octree = static_cast<Octree *>(node);

	// HACK: if there are subtrees, they are empty => we are not interested in them
	return octree->numNodes() == (int)octree->mNodes.size();
}
//-----------------------------------------------------------------------
bool OctreeHierarchyInterface::HasGeometry(GtpVisibility::HierarchyNode *node) const
{
	return !(static_cast<Octree *>(node))->mNodes.empty();
}
//-----------------------------------------------------------------------
float OctreeHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const
{
	const Vector3 bmin = static_cast<Octree *>(node)->mBox.getMinimum();
	const Vector3 bmax = static_cast<Octree *>(node)->mBox.getMaximum();

	const Vector3 pos = (bmax - bmin) * 0.5f + bmin;
	
	return (mCameraPosition - pos).squaredLength();
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::SetNodeVisible(GtpVisibility::HierarchyNode *node, 
											  const bool visible) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	static_cast<Octree *>(node)->setOctreeVisible(visible);
#endif
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::SetLastVisited(GtpVisibility::HierarchyNode *node, 
											  const unsigned int frameId) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	static_cast<Octree *>(node)->setLastVisited(frameId);
#endif
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) const
{		
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	Octree *octant = static_cast<Octree *>(node);

	while (octant && !octant->isOctreeVisible())
	{
		octant->setOctreeVisible(true);
		octant = octant->getParent();
	}
#endif
}
//-----------------------------------------------------------------------
/*void OctreeHierarchyInterface::PullUpFullVisibility(GtpVisibility::HierarchyNode *node) const
{		
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	Octree *octant = static_cast<Octree *>(node);

	for (int i = 0; i < 8; ++ i)
	{
		int x = (i & 4) / 4;
		int y = (i & 2) / 2;
		int z = i & 1;
		
		if ((nextChild = octant->mChildren[x][y][z]) != NULL)
		{
			DetermineFullVisibility(nextChild);
			// this leaf is not fully visible => break
			if (!nextChild->isOctreeFullyVisible())
				octant->setOctreeFullyVisible(false);
		}
	}

	while (octant && !octant->isOctreeVisible())
	{
		octant->setOctreeVisible(true);
		octant = octant->getParent();
	}
#endif
}*/
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::DetermineFullVisibility(GtpVisibility::HierarchyNode *node) const
{		
	Octree *octant = static_cast<Octree *>(node);

	// leaf node: terminate recursion
	if (IsLeaf(node))
	{
		octant->setOctreeFullyVisible(octant->isOctreeVisible());	
		return;
	}

	octant->setOctreeFullyVisible(true);
	
	Octree *nextChild;
	
	for (int i = 0; i < 8; ++ i)
	{
		int x = (i & 4) / 4;
		int y = (i & 2) / 2;
		int z = i & 1;
		
		if ((nextChild = octant->mChildren[x][y][z]) != NULL)
		{
			DetermineFullVisibility(nextChild);
			// this leaf is not fully visible => break
			if (!nextChild->isOctreeFullyVisible())
				octant->setOctreeFullyVisible(false);
		}
	}
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::RenderNode(GtpVisibility::HierarchyNode *node)
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	Octree *octant = static_cast<Octree *>(node);

	if (octant->lastRendered() != mFrameId)
	{
		octant->setLastRendered(mFrameId);
		OctreeSceneManager *ocm = 
			static_cast<OctreeSceneManager *>(mSceneManager);

		ocm->_renderOctant(mCamera, 
						   octant, 
						   mOnlyShadowCasters, 
						   mLeavePassesInQueue);

		mVisibleNodes.push_back(node);
	}
#endif	
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::RenderNodeRecursive(GtpVisibility::HierarchyNode *node)
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	Octree *octant = static_cast<Octree *>(node);

	if (octant->lastRendered() != mFrameId)
	{
		octant->setLastRendered(mFrameId);

		OctreeSceneManager *ocm = 
			static_cast<OctreeSceneManager *>(mSceneManager);

		ocm->_renderOctantRecursive(mCamera, 
									octant, 
									mOnlyShadowCasters, 
									mLeavePassesInQueue);

		mVisibleNodes.push_back(node);
	}
#endif	
}
//-----------------------------------------------------------------------
bool OctreeHierarchyInterface::IsNodeVisible(GtpVisibility::HierarchyNode *node) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	return static_cast<Octree *>(node)->isOctreeVisible();
#else
	return true;
#endif
}
//-----------------------------------------------------------------------
bool OctreeHierarchyInterface::IsNodeFullyVisible(GtpVisibility::HierarchyNode *node) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	return static_cast<Octree *>(node)->isOctreeFullyVisible();
#else
	return true;
#endif
}
//-----------------------------------------------------------------------
unsigned int OctreeHierarchyInterface::LastVisited(GtpVisibility::HierarchyNode *node) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	return static_cast<Octree *>(node)->lastVisited();
#else
	return 0;
#endif
}
//-----------------------------------------------------------------------
AxisAlignedBox *OctreeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node)
{
	// reuse box if node is the same
	// only create renderable bounding box for new node
	if (node != mSavedNode)
	{
		mSavedNode = node;
	    //static_cast<Octree *>(node)->_getCullBounds(&mBox);
		mBox = static_cast<Octree *>(node)->_getWorldAABB();
	}

	return &mBox;
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::VisualizeCulledNode(GtpVisibility::HierarchyNode *node, 
												   GtpVisibility::CullingType type) const
{
	WireBoundingBox *box = static_cast<Octree *>(node)->getWireBoundingBox();

	if (type == GtpVisibility::FRUSTUM_CULLED)
	{
		box->setMaterial("FrustumCulledNodesMaterial");
	}
	else // type == GtpVisibility::QUERY_CULLED
	{
		box->setMaterial("QueryCulledNodesMaterial");
	}

	static_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box);
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,
												   GeometryVector *geometryList, 
												   bool includeChildren)
{
	NodeList::const_iterator nodeIt, nodeIt_end;
	nodeIt_end = static_cast<Octree *>(node)->mNodes.end();

	for (nodeIt = static_cast<Octree *>(node)->mNodes.begin(); nodeIt != nodeIt_end; ++nodeIt)
	{
		SceneNodeHierarchyInterface::GetNodeGeometryList(*nodeIt, geometryList, includeChildren);
	}
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::CollectLeaves(GtpVisibility::HierarchyNode *root, 
											 GtpVisibility::HierarchyNodeContainer &nodes)
{
	std::stack<GtpVisibility::HierarchyNode *> tStack;
	tStack.push(root);

	Octree *child;

	while (!tStack.empty())
	{
		GtpVisibility::HierarchyNode *node = tStack.top();
		tStack.pop();

		if (IsLeaf(node))
		{
			nodes.push_back(node);
		}
		else
		{
			Octree *octree = static_cast<Octree *>(node);
			
			for (int i = 0; i < 8; ++ i)
			{
				int x = (i & 4) / 4;
				int y = (i & 2) / 2;
				int z = i & 1;
	
				if ((child = octree->mChildren[x][y][z]) != NULL)
				{
					tStack.push(child);
				}
			}
		}
	}
}


} // namespace Ogre