#include "OgreCausticRecieverRenderTechnique.h"
#include "OgreTechniqueGroup.h"
#include "OgreIlluminationManager.h"
#include "OgreCausticCubeMapRenderingRun.h"
#include "OgreCubeMapRenderingRun.h"

OgreCausticRecieverRenderTechnique::OgreCausticRecieverRenderTechnique(
												int maxcasters,
												String causticVertexProgram,
												String causticFragmentProgram,
												Pass* pass,
												OgreRenderable* parentRenderable,
												OgreTechniqueGroup* parentTechniqueGroup)
							:RenderTechnique( parentRenderable, parentTechniqueGroup),
							OgreRenderTechnique(pass, parentRenderable, parentTechniqueGroup),
							CausticRecieverRenderTechnique(parentRenderable, parentTechniqueGroup)
{
	this->maxcasters = maxcasters;
	this->causticVertexProgram = causticVertexProgram;
	this->causticFragmentProgram = causticFragmentProgram;
	
	//insert new passes
	Ogre::Technique* techn = pass->getParent();
	Technique::PassIterator it = techn->getPassIterator();
	
	int index = 0;
	while(it.hasMoreElements())
	{
		if( it.getNext() == pass)
			break;
		index++;
		it.moveNext();
	}
	
	index++;
	for(int i = 0; i < maxcasters; i++)
	{
		int lastpass = techn->getNumPasses();
		Pass* newpass = techn->createPass();
		passes.push_back(newpass);

		newpass->setVertexProgram(causticVertexProgram);
		newpass->setFragmentProgram(causticFragmentProgram);
		
		GpuProgramParameters* Vparams = newpass->getVertexProgramParameters().getPointer();
		Vparams->setNamedAutoConstant("WorldViewProj",
									GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
		Vparams->setNamedAutoConstant("World",
									GpuProgramParameters::ACT_WORLD_MATRIX);
		GpuProgramParameters* Fparams = newpass->getFragmentProgramParameters().getPointer();
		Fparams->setNamedConstant("cubeMapCameraPosition", Vector3(0,0,0));

		TextureUnitState* st = newpass->createTextureUnitState();
		TextureUnitState* st2 = newpass->createTextureUnitState();

		st->setTextureFiltering(TFO_BILINEAR);
		st2->setTextureFiltering(TFO_BILINEAR);

		newpass->setSceneBlending(SBF_DEST_COLOUR, SBF_ONE);
		//newpass->setSceneBlending(SBF_ONE, SBF_ZERO);
		newpass->setDepthBias(5);
		//newpass->setSceneBlending(SBT_ADD);
		
		techn->movePass(lastpass, index);			
	}
	
}

OgreCausticRecieverRenderTechnique::~OgreCausticRecieverRenderTechnique()
{

}

void OgreCausticRecieverRenderTechnique::update(unsigned long frameNum)
{
	//find nearest casters
	causticCasters.clear();
	OgreIlluminationManager::getSingleton().getNearestCausticCasters(
				((OgreSharedRuns*)sharedRuns)->getRootPosition(),
				&causticCasters,
				maxcasters);
	//fill passes
	for(unsigned int i = 0; i < passes.size(); i++)
	{
		if(causticCasters.size() > i)
		{
			
			//update caustic caster
			causticCasters.at(i)->updateRun(ILLUMRUN_PHOTONMAP, frameNum);	
			causticCasters.at(i)->updateRun(ILLUMRUN_CAUSTIC_CUBEMAP, frameNum);

			//set texture to pass
			OgreCausticCubeMapRenderingRun* cauCubeRun = 
				(OgreCausticCubeMapRenderingRun*) causticCasters.at(i)->
					getRun(ILLUMRUN_CAUSTIC_CUBEMAP)->asOgreRenderingRun();
			passes.at(i)->getTextureUnitState(0)->setTextureName(
				cauCubeRun->getCausticCubeMapTextureName());

			OgreCubeMapRenderingRun* distCubeRun = 
				(OgreCubeMapRenderingRun*) causticCasters.at(i)->
					getRun(ILLUMRUN_DISTANCE_CUBEMAP)->asOgreRenderingRun();
			passes.at(i)->getTextureUnitState(1)->setTextureName(
				distCubeRun->getCubeMapTextureName());
			
			//set caster position
			GpuProgramParameters* Fparams = passes.at(i)->getFragmentProgramParameters().getPointer();
			Fparams->setNamedConstant("cubeMapCameraPosition",
				causticCasters.at(i)->getRootPosition(ILLUMRUN_CAUSTIC_CUBEMAP));
			Fparams->setNamedConstant("attenuation", cauCubeRun->getAttenuation());
			passes.at(i)->setActive(true);
		}	
		else
			passes.at(i)->setActive(false);

	}
}


namespace CausticRecieverParsers
{
	///Technique parsers
	void parseMaxCasters(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticRecieverRenderTechniqueFactory* f = (OgreCausticRecieverRenderTechniqueFactory*) factory;
		f->maxcasters =  StringConverter::parseInt(params);
	}

	void parseVertexProgram(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticRecieverRenderTechniqueFactory* f = (OgreCausticRecieverRenderTechniqueFactory*) factory;
		f->causticVertexProgram =  params;
	}

	void parseFragmentProgram(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticRecieverRenderTechniqueFactory* f = (OgreCausticRecieverRenderTechniqueFactory*) factory;
		f->causticFragmentProgram =  params;
	}
	
}
OgreCausticRecieverRenderTechniqueFactory::OgreCausticRecieverRenderTechniqueFactory()
{
	typeName = "CausticReciever";

	using namespace CausticRecieverParsers;
	//register parsers
	this->attributeParsers.insert(AttribParserList::value_type("max_caster_count", (ILLUM_ATTRIBUTE_PARSER) parseMaxCasters));
	this->attributeParsers.insert(AttribParserList::value_type("vertex_program_name", (ILLUM_ATTRIBUTE_PARSER) parseVertexProgram));
	this->attributeParsers.insert(AttribParserList::value_type("fragment_program_name", (ILLUM_ATTRIBUTE_PARSER) parseFragmentProgram));
	
}

OgreRenderTechnique* OgreCausticRecieverRenderTechniqueFactory::createInstance( 
										IllumTechniqueParams* params,
										Pass* pass,
										OgreRenderable* parentRenderable,
										OgreTechniqueGroup* parentTechniqueGroup)
{	
	//reset parameters
	maxcasters = 1;
	causticVertexProgram = "GTP/Basic/Shaded_VS";
	causticFragmentProgram = "GTP/Caustic/GatherCaustic_Cube_PS";

	parseParams(params);

	OgreCausticRecieverRenderTechnique* result = new OgreCausticRecieverRenderTechnique(
												maxcasters,
												causticVertexProgram,
												causticFragmentProgram,
												pass,
												parentRenderable,
												parentTechniqueGroup);

	return result;
}