#include "OgreRenderingrun.h"

MovablePlane* OgreRenderingRun::fullScreenQuad = NULL;
Entity* OgreRenderingRun::fullScreenQuadEntity = NULL;
SceneNode* OgreRenderingRun::fullScreenQuadNode = NULL;

class MaterialSetVisitor : public QueuedRenderableVisitor
{
private:
	String materialName;
	std::map<Renderable*, String>* visibleObjects;
public:
    
	MaterialSetVisitor(String& materialName, std::map<Renderable*, String>* visibleObjects)
	{
		this->materialName = materialName;
		this->visibleObjects = visibleObjects;
	}

	void visit(const Renderable* r)
	{	
		Renderable* rend = (Renderable*) r; //sorry for removing the const
		
		if( visibleObjects->count(rend) == 0)
		{
			(*visibleObjects)[rend] = rend->getMaterial().getPointer()->getName();
			rend->setMaterialName(materialName);
		}
	}
	bool visit(const Pass* p){return true;}
	void visit(const RenderablePass* rp){}

};

Vector3 OgreRenderingRun::getCubeMapFaceDirection(unsigned char faceId)
{
	switch(faceId)
	{
		case 0: //positive X
			return Vector3(1,0,0);
		case 1:	//negative X
			return Vector3(-1,0,0);
		case 2:	 //positiove Y
			return Vector3(0,1,0);
		case 3:	//negative Y
			return Vector3(0,-1,0);
		case 4:	 //positiove Z
			return Vector3(0,0,-1);
		case 5:	//negative Z
			return Vector3(0,0,1);
		default:
			return Vector3(0,0,0);
	}
}

Texture* OgreRenderingRun::createCubeRenderTexture(String name,  const Vector3 position, unsigned int resolution, PixelFormat format, int numMips, ColourValue clearColor)
{
	//create texture
	TexturePtr texPtr = Ogre::TextureManager::getSingleton().createManual(	name, 
																			"default",
																			TEX_TYPE_CUBE_MAP,
																			resolution,
																			resolution,
																			0,
																			numMips,
																			format,
																			TU_RENDERTARGET);
	Texture* result = texPtr.getPointer();

	//add viewports to faces
	for(unsigned int i = 0; i < 6; i++)
	{
		Camera* cam = Root::getSingleton()._getCurrentSceneManager()
			->createCamera(name + "CUBEMAPFACE_" + StringConverter::toString(i) + "_CAMERA");
		
		cam->setPosition(position);
		cam->setAspectRatio(1);
		cam->setFOVy(Radian(Degree(90)));
		cam->setNearClipDistance(0.1);

		//set camera orientation
		switch(i)
		{
			case 2:
				cam->setOrientation(Quaternion(Radian(Degree(90)),Vector3(1,0,0)));
				break;
			case 3:
				cam->setOrientation(Quaternion(Radian(Degree(90)),Vector3(-1,0,0)));
				break;
			default:
				cam->setDirection(getCubeMapFaceDirection(i));
				break;
		}

		HardwarePixelBuffer* hpb = (result->getBuffer(i, 0)).getPointer();
		RenderTarget* rt = hpb->getRenderTarget(0);
		Viewport* v = rt->addViewport(cam);
		v->setOverlaysEnabled(false);
		rt->setAutoUpdated(false);

		Root::getSingleton().getRenderSystem()->_setViewport(v);
		Root::getSingleton().getRenderSystem()->clearFrameBuffer( FBT_COLOUR, clearColor);
	}

	return result;

}

void OgreRenderingRun::setMaterialForRenderables(String& materialName, RenderQueue* rq)
{
	RenderQueue::QueueGroupIterator queueIt = rq->_getQueueGroupIterator();
   
    while (queueIt.hasMoreElements())
    {
        RenderQueueGroup* pGroup = queueIt.getNext();
		
        RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();

		while (groupIt.hasMoreElements())
		{
			RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
			const QueuedRenderableCollection& solids = pPriorityGrp->getSolidsBasic();
			const QueuedRenderableCollection& transparents = pPriorityGrp->getTransparents();
			MaterialSetVisitor visitor(materialName, &visibleObjects);	
			solids.acceptVisitor(&visitor, QueuedRenderableCollection::OM_PASS_GROUP);
			transparents.acceptVisitor(&visitor, QueuedRenderableCollection::OM_SORT_ASCENDING);		
		}			
    }

	//refill renderqueue	
	rq->clear();

	std::map<Renderable*, String>::iterator it = visibleObjects.begin();
	std::map<Renderable*, String>::iterator itend = visibleObjects.end();

	while(it != itend)
	{
		rq->addRenderable((*it).first);
		it++;
	}

	SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
	sm->setFindVisibleObjects(false);	
}

void OgreRenderingRun::setMaterialForVisibles(String& materialName, Camera* cam, bool shadowcastersonly)
{
	SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
	
	RenderQueue* rq = sm->getRenderQueue();
	rq->clear();

	RenderQueue::QueueGroupIterator groupIter = rq->_getQueueGroupIterator();
	while (groupIter.hasMoreElements())
	{
		RenderQueueGroup* g = groupIter.getNext();
		g->defaultOrganisationMode();
	}

	sm->_findVisibleObjects (cam, shadowcastersonly);
	
	setMaterialForRenderables(materialName, rq);
}

void OgreRenderingRun::restoreMaterials()
{
	std::map<Renderable*, String>::iterator it = visibleObjects.begin();
	std::map<Renderable*, String>::iterator itend = visibleObjects.end();

	while(it != itend)
	{
		((*it).first)->setMaterialName((*it).second);
		it++;
	}
	
	visibleObjects.clear();

	SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
	sm->setFindVisibleObjects(true);
}

void OgreRenderingRun::renderFullscreenQuad(String materialName, RenderTarget* target)
{
    SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
			
	if(fullScreenQuad == NULL)
	{
		fullScreenQuad = new MovablePlane("PASS_FULLSCREENQUAD_PLANE");
		fullScreenQuad->d = 0;
        fullScreenQuad->normal = Vector3::UNIT_Z;
		MeshManager::getSingleton().createPlane("PASS_FULLSCREENQUAD_MESH", 
            ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, 
            *fullScreenQuad, 2, 2, 
            1, 1, true, 1, 1, 1, Vector3::UNIT_Y);
		fullScreenQuadEntity = sm->createEntity( "PASS_FULLSCREENQUAD_ENTITY", "PASS_FULLSCREENQUAD_MESH" );
		sm->getRootSceneNode()->attachObject(fullScreenQuadEntity);
		fullScreenQuadEntity->setVisible(false);
	}

	fullScreenQuadEntity->setMaterialName(materialName);
	sm->getRenderQueue()->clear();
	sm->getRenderQueue()->addRenderable(fullScreenQuadEntity->getSubEntity(0));
	sm->setFindVisibleObjects(false);
	target->update();
	sm->setFindVisibleObjects(true);
}

void OgreRenderingRun::renderFullscreenGrid(String& materialName, RenderTarget* rt, int width, int height)
{
	MeshPtr mesh = MeshManager::getSingleton().createManual("FullScreenGrid",ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
	SubMesh* sm = mesh->createSubMesh();
	sm->
}

void OgreRenderingRun::renderPixelSprites(String& materialName, RenderTarget* rt, int width, int height)
{
	SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
	
	if(pixelSprites == 0)
	{	
		int resolutionX = width;
		int resolutionY = height;
		pixelSprites = new BillboardSet(spriteSetName, resolutionX * resolutionY, true);
		pixelSprites->setBillboardsInWorldSpace(true);
		pixelSprites->setCullIndividually(false);
		pixelSprites->setPointRenderingEnabled(true);
		//pixelSprites->setDefaultDimensions(1.0 / (float) resolutionX, 1.0 / resolutionY);
		pixelSprites->beginBillboards();
		for(int i = 0; i < resolutionX; i++)
		{
			for(int j = 0; j < resolutionY; j++)
			{				
				Billboard bb( Vector3(
										( (float)i + 0.5 )/ (float) resolutionX, //position x
										( (float)j + 0.5 )/ (float) resolutionY, //position y
 										0),
							  pixelSprites);
				bb.setDimensions(1.0 / (float) resolutionX, 1.0 / resolutionY);				
				pixelSprites->injectBillboard(bb);				
			}
		}
		pixelSprites->endBillboards();

		sm->getRootSceneNode()->attachObject(pixelSprites);
		
		pixelSprites->setVisible(false);
	}
	
	pixelSprites->setMaterialName(materialName);

	sm->getRenderQueue()->clear();
	sm->getRenderQueue()->addRenderable(pixelSprites);
	sm->setFindVisibleObjects(false);
	rt->update();
	sm->setFindVisibleObjects(true);
		
}