#include "OgrePhotonMapRenderingRun.h"
//#include "OgreIlluminationManager.h"
#include "OgreCubeMapRenderingRun.h"


OgrePhotonMapRenderingRun::OgrePhotonMapRenderingRun(OgreSharedRuns* sharedRuns,
														   String name,
														   unsigned long startFrame,
															unsigned long updateInterval,
															unsigned int resolution,
														   String materialName,
														    bool useDistance
														   )
														   :PhotonMapRenderingRun( startFrame, updateInterval)
														   , OgreRenderingRun(startFrame, updateInterval)
														   , RenderingRun(startFrame, updateInterval)
{
	this->useDistance = useDistance;
	this->sharedRuns = sharedRuns;
	this->name = name;	
	this->resolution = resolution;
	this->light = 0;
	this->materialName = materialName;

	createPhotonMap();	
}

void OgrePhotonMapRenderingRun::createPhotonMap()
{
	TexturePtr texPtr = Ogre::TextureManager::getSingleton().createManual(name, 
																		"default",
																		TEX_TYPE_2D,
																		resolution,
																		resolution,
																		0,
																		0,
																		PF_FLOAT32_RGBA,
																		TU_RENDERTARGET);
	 photonMapTexture = texPtr.getPointer();
	 photonMapCamera = Root::getSingleton()._getCurrentSceneManager()->createCamera(name + "_CAMERA");
	 //add viewport to rendertarget
	 HardwarePixelBuffer* hpb = (photonMapTexture->getBuffer()).getPointer();
	 RenderTarget* rt = hpb->getRenderTarget();
	 Viewport* v = rt->addViewport(photonMapCamera);
	 v->setOverlaysEnabled(false);
	 rt->setAutoUpdated(false);

	 photonMapCamera->setLodBias(0.0001);
}

void OgrePhotonMapRenderingRun::updateFrame(unsigned long frameNum)
{
	refreshLight();

	if(useDistance)
	{
		sharedRuns->updateRun(ILLUMRUN_DISTANCE_CUBEMAP, frameNum);
	}

	Material* mat = (Material*) MaterialManager::getSingleton().getByName(materialName).getPointer();
	GpuProgramParameters* Fparams = mat->getTechnique(0)->getPass(0)->getFragmentProgramParameters().getPointer();
	Fparams->setNamedConstant("lastCenter",	sharedRuns->getRootPosition(ILLUMRUN_PHOTONMAP));
	
    SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
	RenderQueue* rq = sm->getRenderQueue();
	rq->clear();

	((OgreSharedRuns*)sharedRuns->getRoot(ILLUMRUN_PHOTONMAP))->notifyCamera(photonMapCamera);
	((OgreSharedRuns*)sharedRuns->getRoot(ILLUMRUN_PHOTONMAP))->addRenderablesToQueue(rq);
	
	setMaterialForRenderables(materialName,rq);
	
	RenderTarget* rt = photonMapTexture->getBuffer().getPointer()->getRenderTarget();
	 
	rt->update();	
	/*
	static int framecount = 0;
	String filename = "photon";
	filename.append(this->name);
	//filename.append(StringConverter::toString(framecount));
	filename.append(".png");
	rt->writeContentsToFile(filename);
	framecount++;*/
	
	restoreMaterials();
}

void OgrePhotonMapRenderingRun::refreshLight()
{
	///TODO:
	///search nearest light, set light params
	SceneManager* sm = Root::getSingleton()._getCurrentSceneManager();
	LightList list;
	sm->_populateLightList(((OgreSharedRuns*)sharedRuns)->getRootPosition(ILLUMRUN_PHOTONMAP),100000, list);
	
	light = *(list.begin());

	if(light!= 0)
	{
		if(light->getType() == Light::LT_DIRECTIONAL)
		{
			Vector3 dir = light->getDirection();
			photonMapCamera->setDirection( dir );
			Real r = sharedRuns->getRootBoundingSphere(ILLUMRUN_PHOTONMAP).getRadius();
			photonMapCamera->setPosition( sharedRuns->getRootPosition(ILLUMRUN_PHOTONMAP) - dir * r);
			photonMapCamera->setProjectionType(PT_ORTHOGRAPHIC);
			Matrix4 proj;
			proj = Matrix4::IDENTITY;
			proj.setScale(Vector3(1.0/r, 1.0/r, -1.5/r));
			//proj.setTrans(Vector3(0,0,-1));
			photonMapCamera->setCustomProjectionMatrix(true,proj);
		}
		else
		{			
			Vector3 pos = light->getParentSceneNode()->getPosition();
			Vector3 dir = sharedRuns->getRootPosition(ILLUMRUN_PHOTONMAP) - pos;
			Real r = sharedRuns->getRootBoundingSphere(ILLUMRUN_PHOTONMAP).getRadius();
			Real d = dir.length();
			dir.normalise();
			float mindist = 1.5 * r;
			if(d < mindist)
			{
				pos -= dir * (mindist - d) ;
				d = mindist;
			}
			photonMapCamera->setPosition(pos);
			Radian alfa = Math::ASin(r/d);
			photonMapCamera->setFOVy(2*alfa);
			photonMapCamera->setDirection( dir );

			photonMapCamera->setNearClipDistance(std::max(0.01f, d - r));
			photonMapCamera->setFarClipDistance(r + d);	
		}
	}
}

void OgrePhotonMapRenderingRun::distanceCubeMapChanged(RenderingRun* run)
{
	Material* mat = (Material*) MaterialManager::getSingleton().getByName(materialName).getPointer();
	OgreCubeMapRenderingRun* cuberun =(OgreCubeMapRenderingRun*) (run->asOgreRenderingRun());
	String cubemapname = cuberun->getCubeMapTextureName();
	mat->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName(cubemapname);
}

void OgrePhotonMapRenderingRun::distanceCubeMapUpdated(RenderingRun* run)
{
	Material* mat = (Material*) MaterialManager::getSingleton().getByName(materialName).getPointer();
	OgreCubeMapRenderingRun* cuberun =(OgreCubeMapRenderingRun*) (run->asOgreRenderingRun());
	String cubemapname = cuberun->getCubeMapTextureName();
	GpuProgramParametersSharedPtr fpParams = mat->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
	Vector3 center = ((OgreSharedRuns*) sharedRuns)->getRootPosition(ILLUMRUN_DISTANCE_CUBEMAP);
	fpParams->setNamedConstant("lastCenter",center);
}