#include "OgrePlatformQueryManager.h"
#include "OcclusionQuery.h"
#include <OgreSceneManager.h>
#include <OgreLogManager.h>
#include <OgreStringConverter.h>
#include <vector>
#include <OgreSubEntity.h>
#include "OgrePlatformHierarchyInterface.h"



namespace Ogre {

//-----------------------------------------------------------------------
void PlatformQueryManager::SetViewport(Viewport *vp)
{
	mViewport = vp;
}
//-----------------------------------------------------------------------
void PlatformQueryManager::ComputeFromPointVisibility(
											const Vector3 &point,
											NodeInfoContainer *visibleNodes,
											MeshInfoContainer *visibleGeometry,
											PatchInfoContainer *visiblePatches,
											const bool relativeVisibility,
											const bool approximateVisibility)
{
	SceneManager *sm = static_cast<PlatformHierarchyInterface *>
								(mHierarchyInterface)->GetSceneManager();

	// create a camera for the point query
	Camera *cam = sm->createCamera("PointQueryCam");	

	//save old camera
	Camera *savedCam = mViewport->getCamera();
	
	
	//////////////
	//-- initialise new camera

	mViewport->setCamera(cam);
	cam->setPosition(point);

	cam->setNearClipDistance(savedCam->getNearClipDistance());
	cam->setFarClipDistance(savedCam->getFarClipDistance());

	// set frustum to 45 degrees so all the scene can be captured with 6 shots
	cam->setAspectRatio(1.0);
	cam->setFOVy(Radian(Math::HALF_PI));

	int sign = -1;
	
	///////////////
	//-- capture visibility from all 6 directions

	for (int dir=0; dir < 6; dir++)	
	{
		sign *= -1;
		
		// Print camera details
      	if (0)
		{
			std::stringstream d;
			d << "Point query camera: " + StringConverter::toString(cam->getDerivedPosition()) + 
				" " + "O: " + StringConverter::toString(cam->getDerivedOrientation());
			LogManager::getSingleton().logMessage(d.str());
		}

		// prevent from initialising geometry / node array again
		if (dir > 0)
			mWasInitialised = true;

		ComputeCameraVisibility(*cam, 
								visibleNodes, 
								visibleGeometry, 
								visiblePatches, 
			                    relativeVisibility,
								approximateVisibility);

		// permute directions
		Vector3 direction(0,0,0);
		direction[dir / 2] = sign;

		cam->setDirection(direction);
	}
	
	// reset camera
	mViewport->setCamera(savedCam);
}
//-----------------------------------------------------------------------
void PlatformQueryManager::ComputeCameraVisibility(
									const Camera &camera,
									NodeInfoContainer *visibleNodes,
									MeshInfoContainer *visibleGeometry,
									PatchInfoContainer *visiblePatches,
									const bool relativeVisibility,
									const bool approximateVisibility)
{
	// we need access to the scene manager and the rendersystem
	PlatformHierarchyInterface *pfHierarchyInterface = 
		static_cast<PlatformHierarchyInterface *>(mHierarchyInterface);

	SceneManager *sm = pfHierarchyInterface->GetSceneManager();


	// const_cast allowed because camera is not changed in renderScene
	Camera *pCam = const_cast<Camera *>(&camera); 

	// disable overlays, reset them later
	bool overlayEnabled = mViewport->getOverlaysEnabled();
	mViewport->setOverlaysEnabled(false);
	
	// clear background with black (i.e., not a valid item id)
	ColourValue bg = mViewport->getBackgroundColour();
	mViewport->setBackgroundColour(ColourValue(0, 0, 0, 0));
	//pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_COLOUR | FBT_DEPTH);

	// render scene once to fill depth buffer
	sm->_renderScene(pCam, mViewport, false); 
   
	mWasInitialised = false; // reset flag
	mViewport->setOverlaysEnabled(overlayEnabled); // reset old overlay status
	mViewport->setBackgroundColour(bg); // reset background color
}

} // namespace Ogre