#include "OgreConvolvedCubeMapRenderTechnique.h"
#include "OgreTechniqueGroup.h"
#include "OgreReducedCubeMapRenderingRun.h"
#include "OgreColorCubeMapRenderingRun.h"

OgreConvolvedCubeMapRenderTechnique::OgreConvolvedCubeMapRenderTechnique(unsigned long startFrame,
														unsigned long cubeMapUpdateInterval,
														unsigned int cubeMapResolution,
														unsigned int reducedCubeMapResolution,
														unsigned char reducedTexID,
														bool useDistCalc,
														bool useFaceAngleCalc,
														float distTolerance,
														float angleTolerance,
														bool updateAllFace,
														Pass* pass,
														OgreRenderable* parentRenderable,
														OgreTechniqueGroup* parentTechniqueGroup)
							:OgreRenderTechnique( pass, parentRenderable, parentTechniqueGroup),
							ConvolvedCubeMapRenderTechnique(startFrame, cubeMapUpdateInterval, cubeMapResolution, reducedCubeMapResolution, useDistCalc, useFaceAngleCalc, distTolerance, angleTolerance, updateAllFace, parentRenderable, parentTechniqueGroup),
							RenderTechnique(parentRenderable, parentTechniqueGroup) 
{	
	this->reducedTexID = reducedTexID;
		
	if(sharedRuns->getRun(ILLUMRUN_COLOR_CUBEMAP) == 0)
		sharedRuns->addRun(ILLUMRUN_COLOR_CUBEMAP, createColorCubeMapRun());

	if(sharedRuns->getRun(ILLUMRUN_REDUCED_CUBEMAP) == 0)
		sharedRuns->addRun(ILLUMRUN_REDUCED_CUBEMAP, createReducedCubeMapRun());

	colorCubeMapRunChanged(sharedRuns->getRun(ILLUMRUN_COLOR_CUBEMAP));
	reducedCubeMapRunChanged(sharedRuns->getRun(ILLUMRUN_REDUCED_CUBEMAP));	
}


OgreConvolvedCubeMapRenderTechnique::~OgreConvolvedCubeMapRenderTechnique()
{

}

void OgreConvolvedCubeMapRenderTechnique::update(unsigned long frameNum)
{
	ConvolvedCubeMapRenderTechnique::update(frameNum);
}

void OgreConvolvedCubeMapRenderTechnique::reducedCubeMapRunChanged(RenderingRun* run)
{
	OgreReducedCubeMapRenderingRun* cuberun =(OgreReducedCubeMapRenderingRun*) (run->asOgreRenderingRun());
	String cubemapname = cuberun->getReducedCubeMapTextureName();
	
	pass->getTextureUnitState(reducedTexID)->setTextureName(cubemapname);
}

void OgreConvolvedCubeMapRenderTechnique::colorCubeMapRunChanged(RenderingRun* run)
{
	
	OgreColorCubeMapRenderingRun* cuberun =(OgreColorCubeMapRenderingRun*) (run->asOgreRenderingRun());
	String cubemapname = cuberun->getColorCubeMapTextureName();
	
	OgreReducedCubeMapRenderingRun* rr = (OgreReducedCubeMapRenderingRun*) sharedRuns->getRun(ILLUMRUN_REDUCED_CUBEMAP)->asOgreRenderingRun();
	rr->colorCubeMapChanged(cubemapname);

}

RenderingRun* OgreConvolvedCubeMapRenderTechnique::createColorCubeMapRun()
{
	return new OgreColorCubeMapRenderingRun( (OgreSharedRuns*) parentTechniqueGroup->getSharedRuns(), 
												parentOgreRenderable->getName()  + "_COLORCUBEMAP",
												startFrame,
												cubeMapUpdateInterval,
												cubeMapResolution,
												useDistCalc,
												useFaceAngleCalc,
												distTolerance,
												angleTolerance,
												updateAllFace);
}

RenderingRun* OgreConvolvedCubeMapRenderTechnique::createReducedCubeMapRun()
{
	return new OgreReducedCubeMapRenderingRun( (OgreSharedRuns*) parentTechniqueGroup->getSharedRuns(), 
												parentOgreRenderable->getName()  + "_COLORCUBEMAP_REDUCED",
												startFrame,
												cubeMapUpdateInterval,
												reducedCubeMapResolution,
												useDistCalc,
												useFaceAngleCalc,
												distTolerance,
												angleTolerance,
												updateAllFace);
}

///Technique Parsers
namespace ConvolvedCubemapParsers
{
	void parseStartFrame(String& params, RenderTechniqueFactory* factory)
	{
		OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory;
		f->startFrame =  StringConverter::parseUnsignedLong(params);
	}
	void parseCubeMapUpdateInterval(String& params, RenderTechniqueFactory* factory)
	{
		OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory;
		f->cubeMapUpdateInterval =  StringConverter::parseUnsignedLong(params);
	}

	void parseCubeMapResolution(String& params, RenderTechniqueFactory* factory)
	{
		OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory;
		f->cubeMapResolution =  StringConverter::parseUnsignedInt(params);
	}

	void parseReducedCubeMapResolution(String& params, RenderTechniqueFactory* factory)
	{
		OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory;
		f->reducedCubeMapResolution =  StringConverter::parseUnsignedInt(params);
	}

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

	void parseUseDistCalc(String& params, RenderTechniqueFactory* factory)
	{
		OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory;
		// format: on/off tolerance(float)
		StringVector vecparams = StringUtil::split(params, " \t");

		if(StringConverter::parseBool(vecparams[0]))//on
		{
			f->useDistCalc = true;

			if(vecparams.size()>1)
			{			
				f->distTolerance = StringConverter::parseReal(vecparams[1]);
			}
		}
		else
		{
			f->useDistCalc = false;
		}
	}

	void parseUseFaceAngleCalc(String& params, RenderTechniqueFactory* factory)
	{
		OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory;
		// format: on/off tolerance(float)
		StringVector vecparams = StringUtil::split(params, " \t");

		if(StringConverter::parseBool(vecparams[0]))//on
		{
			f->useFaceAngleCalc = true;

			if(vecparams.size()>1)
			{			
				f->angleTolerance = StringConverter::parseReal(vecparams[1]);
			}
		}
		else
		{
			f->useFaceAngleCalc = false;
		}
	}

	void parseUpdateAllFace(String& params, RenderTechniqueFactory* factory)
	{
		OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory;
		f->updateAllFace =  StringConverter::parseBool(params);
	}
}
///Technique factory
OgreConvoledCubeMapRenderTechniqueFactory::OgreConvoledCubeMapRenderTechniqueFactory()
{
	typeName = "ReducedColorCubeMap";

	using namespace ConvolvedCubemapParsers;
	//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) parseCubeMapUpdateInterval));
	this->attributeParsers.insert(AttribParserList::value_type("resolution", (ILLUM_ATTRIBUTE_PARSER) parseCubeMapResolution));
	this->attributeParsers.insert(AttribParserList::value_type("reduced_resolution", (ILLUM_ATTRIBUTE_PARSER) parseReducedCubeMapResolution));
	this->attributeParsers.insert(AttribParserList::value_type("texture_unit_id", (ILLUM_ATTRIBUTE_PARSER) parseTexID));
	this->attributeParsers.insert(AttribParserList::value_type("distance_calc", (ILLUM_ATTRIBUTE_PARSER) parseUseDistCalc));
	this->attributeParsers.insert(AttribParserList::value_type("face_angle_calc", (ILLUM_ATTRIBUTE_PARSER) parseUseFaceAngleCalc));
	this->attributeParsers.insert(AttribParserList::value_type("update_all_face", (ILLUM_ATTRIBUTE_PARSER) parseUpdateAllFace));

}

OgreRenderTechnique* OgreConvoledCubeMapRenderTechniqueFactory::createInstance( 
										IllumTechniqueParams* params,
										Pass* pass,
										OgreRenderable* parentRenderable,
										OgreTechniqueGroup* parentTechniqueGroup)
{	
	//reset parameters
	startFrame = 1;
	cubeMapUpdateInterval = 1;
	cubeMapResolution = 256;
	reducedCubeMapResolution = 8;	
	texID = 0;
	useDistCalc = 1;
	useFaceAngleCalc = false;
	distTolerance = 2.0;
	angleTolerance = 2.0;
	updateAllFace = false;

	parseParams(params);

	OgreConvolvedCubeMapRenderTechnique* result = new OgreConvolvedCubeMapRenderTechnique(
												startFrame,
												cubeMapUpdateInterval,
												cubeMapResolution,
												reducedCubeMapResolution,
												texID,
												useDistCalc,
												useFaceAngleCalc,
												distTolerance,
												angleTolerance,
												updateAllFace,
												pass,
												parentRenderable,
												parentTechniqueGroup);

	return result;
}