#ifndef _OcclusionCullingSceneTraverser_H__
#define _OcclusionCullingSceneTraverser_H__

#include "OgreSceneNode.h"
#include "OgreSceneManager.h"
#include "OgrePrerequisites.h"
#include "OgreSolidHalfBoundingBox.h"
#include "OgreCamera.h"
#include "OgreRenderSystem.h"
#include <queue>

using namespace std;

namespace Ogre {
	/**
		This class implements the compare operator for the priority queue.
		a lower distance has a higher value in the queue
	*/
	template <typename T> class myless
	{
	public:
		myless(Camera *cam) { mCamera = cam; }
		//bool operator() (HierarchyNode *v1, HierarchyNode *v2) const
		bool operator() (T v1, T v2) const
		{
			return v1->getSquaredViewDepth(mCamera) > v2->getSquaredViewDepth(mCamera);
		}
	private:
		Camera *mCamera;
	};

	typedef pair<SceneNode *, HardwareOcclusionQuery *> QueryPair;
	typedef priority_queue<SceneNode *, vector<SceneNode *>, myless<vector<SceneNode *>::value_type> > PriorityQueue;
	typedef queue<QueryPair> QueryQueue;
	/**
		Class which implements a scene mangager which uses occlusion queries for culling occluded objects
	*/
	class SceneTraverser
	{
	public:
		/** Construction taking the current scene manager and the current rendersystem as argument
		@param sm current scene manager
		@param rsys current render system 
		*/
		SceneTraverser(SceneManager *sm, RenderSystem *rsys);
		~SceneTraverser();
	
		/** Sets pointer to the current scene manager.
		@param the scene manager */
		void setSceneManager( SceneManager *sm );
		
		/** Sets pointer to the current render system 
		@param the rendersystem */
		void setRenderSystem( RenderSystem *rsys );
		
		/** Sets the root of the scene hierarchy. */
		void setSceneRoot(SceneNode *root);

		/** Doing some necessary preprocessing.
		@comment e.g., initialises occlusion queries */
		//void preprocess( void );

	protected:
	
		/** returns true if current node is leaf of the hierarchy */
		bool isLeaf( ) = 0;
		
		void traverseNode( HierarchyNode *node);
		/** Renders current scene node 
		@param cam current camera
		@param node current scene node to be rendered
		*/
		void renderNode( HierarchyNode *node);
			
		/** Issue a occlusion query for this node. 
			@param box the axis aligned bounding box of the node
			@wasVisible if the node was visible in previous frame
		*/
		HardwareOcclusionQuery *issueOcclusionQuery( AxisAlignedBox *box, bool wasVisible );
		/** Returns next available occlusion query or creates new one.
		@return the next occlusion query
		*/
		HardwareOcclusionQuery *getNextOcclusionQuery(void);
		/** Pulls up the visibility from the child node. 
		@param the child node 
		*/
		void pullUpVisibility(SceneNode *node);
		/** delete all previously defined occlusion queries */
		void deleteQueries();
		/** Renders bounding box of specified node.
		@param box the bounding box of the scene node to be rendered */
		void renderBoundingBox( AxisAlignedBox *box );
		/** Returns one half of the bounding box.
		@param half the half index of the bouding box (0 or 1)
		*/
		SolidHalfBoundingBox *getSolidHalfBoundingBox( int half );

		/** Initialises the distance queue. */
		virtual void initDistanceQueue(Camera *cam);
		
		std::vector<HardwareOcclusionQuery *> mOcclusionQueries;
		// two halfes of a aabb
		SolidHalfBoundingBox *mHalfBoundingBox[2];	

		int mCurrentAlgorithm;

		unsigned int mFrameId;
		unsigned int mVisibilityThreshold;
		
		SceneManager *mSceneManager;
		RenderSystem *mRenderSystem;
	
		int mCurrentTestIdx;
		int mQueryMode;

		unsigned int mNumQueries;

		//--- statistics
		unsigned int mNumSceneNodes;
		unsigned int mNumTraversedNodes;
		unsigned int mNumQueryCulledNodes;
		unsigned int mNumFrustumCulledNodes;
		unsigned int mNumRenderedGeometry;
		unsigned int mNumRenderedNodes;
		
	private:
		// the scene root
		HierarchyNode *mHierarchyRoot;
		// we use a priority queue ordered by distance
		PriorityQueue *mDistanceQueue; 
	};

}
#endif // SCENETRAVERSER_H