#include "OgreCausticCasterRenderTechnique.h"
#include "OgreTechniqueGroup.h"
#include "OgreCausticCubeMapRenderingRun.h"
#include "OgrePhotonMapRenderingRun.h"
#include "OgreCubeMapRenderingRun.h"


OgreCausticCasterRenderTechnique::OgreCausticCasterRenderTechnique(unsigned long startFrame,
																unsigned long photonMapUpdateInterval,
																unsigned int photonMapResolution,
																unsigned int causticCubeMapResolution,
																String photonMapMaterialName,
																String causticMapMaterialName,
																unsigned char photonMapTexID,
																bool updateAllFace,
																bool useDistance,
																float attenuation,
																bool useTriangles,
																bool blurCauCubeMap,
																Pass* pass,
																OgreRenderable* parentRenderable,
																OgreTechniqueGroup* parentTechniqueGroup)
							:OgreRenderTechnique( pass, parentRenderable, parentTechniqueGroup),
							CausticCasterRenderTechnique(startFrame, photonMapUpdateInterval, photonMapResolution, causticCubeMapResolution, updateAllFace, useDistance, parentRenderable, parentTechniqueGroup),
							RenderTechnique( parentRenderable, parentTechniqueGroup)
{	
	this->attenuation = attenuation;
	this->useTriangles = useTriangles;
	this->photonMapMaterialName = photonMapMaterialName;
	this->blurCauCubeMap = blurCauCubeMap;
	
	String newMaterialName = causticMapMaterialName + "_clone_" + parentRenderable->getName();
	Material* mat = (Material*) MaterialManager::getSingleton().getByName(causticMapMaterialName).getPointer();
	Material* newMat = mat->clone(newMaterialName).getPointer();
	this->causticMapMaterialName = newMat->getName();
	//this->causticMapMaterialName =causticMapMaterialName;
		
	this->photonMapTexID = photonMapTexID;
	
	if(sharedRuns->getRun(ILLUMRUN_CAUSTIC_CUBEMAP) == 0)
		sharedRuns->addRun(ILLUMRUN_CAUSTIC_CUBEMAP, createCausticCubeMapRun());
	if(sharedRuns->getRun(ILLUMRUN_PHOTONMAP) == 0)
		sharedRuns->addRun(ILLUMRUN_PHOTONMAP, createPhotonMapRun());

	if(useDistance)
	{
		if(sharedRuns->getRun(ILLUMRUN_DISTANCE_CUBEMAP) == 0)
			sharedRuns->addRun(ILLUMRUN_DISTANCE_CUBEMAP, createDistanceCubeMapRun());
		distanceCubeMapRunChanged(sharedRuns->getRun(ILLUMRUN_DISTANCE_CUBEMAP));
	}

	photonMapRunChanged(sharedRuns->getRun(ILLUMRUN_PHOTONMAP));
	causticCubeMapRunChanged(sharedRuns->getRun(ILLUMRUN_CAUSTIC_CUBEMAP));
}

OgreCausticCasterRenderTechnique::~OgreCausticCasterRenderTechnique()
{
	MaterialManager::getSingleton().remove(causticMapMaterialName);
}

void OgreCausticCasterRenderTechnique::photonMapRunChanged(RenderingRun* run)
{
	OgreCausticCubeMapRenderingRun* caurun = (OgreCausticCubeMapRenderingRun*) 
				sharedRuns->getRun(ILLUMRUN_CAUSTIC_CUBEMAP)->asOgreRenderingRun();
	caurun->photonMapChanged(sharedRuns->getRun(ILLUMRUN_PHOTONMAP));
}

void OgreCausticCasterRenderTechnique::distanceCubeMapRunChanged(RenderingRun* run)
{
	if(useDistance)
	{
		OgrePhotonMapRenderingRun* photonrun = (OgrePhotonMapRenderingRun*) 
					sharedRuns->getRun(ILLUMRUN_PHOTONMAP)->asOgreRenderingRun();
		photonrun->distanceCubeMapChanged(sharedRuns->getRun(ILLUMRUN_DISTANCE_CUBEMAP));
	}
}
void OgreCausticCasterRenderTechnique::distanceCubeMapRunUpdated(RenderingRun* run)
{
	if(useDistance)
	{
		OgrePhotonMapRenderingRun* photonrun = (OgrePhotonMapRenderingRun*) 
					sharedRuns->getRun(ILLUMRUN_PHOTONMAP)->asOgreRenderingRun();
		photonrun->distanceCubeMapUpdated(sharedRuns->getRun(ILLUMRUN_DISTANCE_CUBEMAP));
	}
}
void OgreCausticCasterRenderTechnique::causticCubeMapRunChanged(RenderingRun* run)
{
}

RenderingRun* OgreCausticCasterRenderTechnique::createPhotonMapRun()
{
	return new OgrePhotonMapRenderingRun((OgreSharedRuns*) sharedRuns,
											parentOgreRenderable->getName()  + "_PHOTONMAP",
											startFrame,
											photonMapUpdateInterval,
											photonMapResolution,
											photonMapMaterialName,
											useDistance);

}

RenderingRun* OgreCausticCasterRenderTechnique::createCausticCubeMapRun()
{
	return new OgreCausticCubeMapRenderingRun((OgreSharedRuns*) sharedRuns,
												parentOgreRenderable->getName()  + "_CAUSTICCUBEMAP",
												startFrame,
												photonMapUpdateInterval,
												causticCubeMapResolution,
												causticMapMaterialName,
												photonMapTexID,
												updateAllFace,
												attenuation,
												useTriangles,
												blurCauCubeMap
												);

}

RenderingRun* OgreCausticCasterRenderTechnique::createDistanceCubeMapRun()
{
	return new OgreCubeMapRenderingRun((OgreSharedRuns*) sharedRuns,
										parentOgreRenderable->getName()  + "_DISTANCECUBEMAP",
										startFrame,
										photonMapUpdateInterval,
										causticCubeMapResolution,
										0,
										0,
										0,
										0,
										updateAllFace,
										false,
										true,
										"",
										"GTP/Basic/Distance",
										"ILLUM_TRIGGER_DISTANCE",
										false,										
										ILLUMRUN_DISTANCE_CUBEMAP);

}

const String& OgreCausticCasterRenderTechnique::getCausticCubeMapName()
{
	return ((OgreCausticCubeMapRenderingRun*) sharedRuns->getRun(ILLUMRUN_CAUSTIC_CUBEMAP)->asOgreRenderingRun())->
		getCausticCubeMapTextureName();
}


///Technique Parsers
namespace CausticCasterParsers
{
	void parseStartFrame(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
		f->startFrame =  StringConverter::parseUnsignedLong(params);
	}
	void parsePhotonMapUpdateInterval(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
		f->photonMapUpdateInterval =  StringConverter::parseUnsignedLong(params);
	}

	void parsePhotonMapResolution(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
		f->photonMapResolution =  StringConverter::parseUnsignedInt(params);
	}

	void parseCausticCubeMapResolution(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
		f->causticCubeMapResolution =  StringConverter::parseUnsignedInt(params);
	}

	void parseTexID(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
		f->photonMapTexID =  StringConverter::parseUnsignedInt(params);
	}

	void parseUseDistance(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
		f->useDistance = StringConverter::parseBool(params);
	}

	void parseUpdateAllFace(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
		f->updateAllFace =  StringConverter::parseBool(params);
	}

	void parsePhotonMapMaterial(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
		f->photonMapMaterialName =  params;
	}

	void parseCauMapMaterial(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
		f->causticMapMaterialName =  params;
	}

	void parseAttenuation(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
		f->attenuation =  StringConverter::parseReal(params);
	}

	void parseUseTriangles(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
		f->useTriangles =  StringConverter::parseBool(params);
	}

	void parseBlurCauCubeMap(String& params, RenderTechniqueFactory* factory)
	{
		OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
		f->blurCauCubeMap =  StringConverter::parseBool(params);
	}
}


///Technique factory
OgreCausticCasterRenderTechniqueFactory::OgreCausticCasterRenderTechniqueFactory()
{
	typeName = "CausticCaster";
	
	using namespace CausticCasterParsers;

	//register parsers
	this->attributeParsers.insert(AttribParserList::value_type("start_frame", (ILLUM_ATTRIBUTE_PARSER) parseStartFrame));
	this->attributeParsers.insert(AttribParserList::value_type("update_interval", (ILLUM_ATTRIBUTE_PARSER) parsePhotonMapUpdateInterval));
	this->attributeParsers.insert(AttribParserList::value_type("photonmap_resolution", (ILLUM_ATTRIBUTE_PARSER) parsePhotonMapResolution));
	this->attributeParsers.insert(AttribParserList::value_type("caustic_cubemap_resolution", (ILLUM_ATTRIBUTE_PARSER) parseCausticCubeMapResolution));
	this->attributeParsers.insert(AttribParserList::value_type("photon_map_material", (ILLUM_ATTRIBUTE_PARSER) parsePhotonMapMaterial));
	this->attributeParsers.insert(AttribParserList::value_type("caustic_map_material", (ILLUM_ATTRIBUTE_PARSER) parseCauMapMaterial));
	this->attributeParsers.insert(AttribParserList::value_type("photon_map_tex_id", (ILLUM_ATTRIBUTE_PARSER) parseTexID));
	this->attributeParsers.insert(AttribParserList::value_type("distance_impostor", (ILLUM_ATTRIBUTE_PARSER) parseUseDistance));
	this->attributeParsers.insert(AttribParserList::value_type("update_all_face", (ILLUM_ATTRIBUTE_PARSER) parseUpdateAllFace));
	this->attributeParsers.insert(AttribParserList::value_type("attenuation", (ILLUM_ATTRIBUTE_PARSER) parseAttenuation));
	this->attributeParsers.insert(AttribParserList::value_type("use_triangles", (ILLUM_ATTRIBUTE_PARSER) parseUseTriangles));
	this->attributeParsers.insert(AttribParserList::value_type("blur_caustic_cubemap", (ILLUM_ATTRIBUTE_PARSER) parseBlurCauCubeMap));
	
}

OgreRenderTechnique* OgreCausticCasterRenderTechniqueFactory::createInstance( 
										IllumTechniqueParams* params,
										Pass* pass,
										OgreRenderable* parentRenderable,
										OgreTechniqueGroup* parentTechniqueGroup)
{	
	//reset parameters
	attenuation = 1.0;
	startFrame = 1;
	photonMapUpdateInterval = 1;
	photonMapResolution = 64;
	causticCubeMapResolution = 128;	
	photonMapMaterialName = "GTP/Caustic/PhotonMap_HitEnv";
	causticMapMaterialName = "GTP/Caustic/CauCube_PointSprite";
	photonMapTexID = 0;
	useDistance = true;
	updateAllFace = false;
	useTriangles = false;
	blurCauCubeMap = false;

	parseParams(params);

	OgreCausticCasterRenderTechnique* result = new OgreCausticCasterRenderTechnique(
												startFrame,
												photonMapUpdateInterval,
												photonMapResolution,
												causticCubeMapResolution,
												photonMapMaterialName,
												causticMapMaterialName,
												photonMapTexID,
												updateAllFace,
												useDistance,
												attenuation,
												useTriangles,
												blurCauCubeMap,
												pass,
												parentRenderable,
												parentTechniqueGroup);
	
	return result;
}