#include "OgreCubeMapRenderTechnique.h"
#include "OgreTechniqueGroup.h"
#include "OgreCubeMapRenderingRun.h"

OgreCubeMapRenderTechnique::OgreCubeMapRenderTechnique(unsigned long startFrame,
														unsigned long cubeMapUpdateInterval,
														unsigned int cubeMapResolution,												
														unsigned char texID,
														bool useDistCalc,
														bool useFaceAngleCalc,
														float distTolerance,
														float angleTolerance,
														bool updateAllFace,
														bool renderSelf,
														bool renderEnvironment,
														String selfMaterial,
														String environmentMaterial,
														int layer,
														bool getMinMax,
														bool attachToTexUnit,
														String minVariableName,
														String maxVariableName,
														String triggerName,
														Pass* pass,
														OgreRenderable* parentRenderable,
														OgreTechniqueGroup* parentTechniqueGroup,
														bool createCubeRun)
							:OgreRenderTechnique( pass, parentRenderable, parentTechniqueGroup),
							CubeMapRenderTechnique(startFrame, cubeMapUpdateInterval, cubeMapResolution, useDistCalc, useFaceAngleCalc, distTolerance, angleTolerance, updateAllFace, renderSelf, renderEnvironment, layer, parentRenderable, parentTechniqueGroup),
							RenderTechnique(parentRenderable, parentTechniqueGroup) 
{	
	this->minVariableName = minVariableName;
	this->maxVariableName = maxVariableName;
	this->attachToTexUnit = attachToTexUnit;
	this->getMinMax = getMinMax;

	this->texID = texID;
	this->selfMaterial = selfMaterial;
	this->environmentMaterial = environmentMaterial;
	texturePostFix = "_CUBEMAP";

	if(createCubeRun)
	{
		if(sharedRuns->getRun(ILLUMRUN_CUBEMAP) == 0)
		sharedRuns->addRun(ILLUMRUN_CUBEMAP, createCubeMapRun());

		cubeMapRunChanged(sharedRuns->getRun(ILLUMRUN_CUBEMAP));
	}
}


OgreCubeMapRenderTechnique::~OgreCubeMapRenderTechnique()
{

}

void OgreCubeMapRenderTechnique::cubeMapRunChanged(RenderingRun* run)
{
	OgreCubeMapRenderingRun* cuberun =(OgreCubeMapRenderingRun*) (run->asOgreRenderingRun());
	String cubemapname = cuberun->getCubeMapTextureName();
	
	if(attachToTexUnit)
		pass->getTextureUnitState(texID)->setTextureName(cubemapname);	
}

void OgreCubeMapRenderTechnique::cubeMapRunUpdated(RenderingRun* run)
{
	OgreCubeMapRenderingRun* cuberun =(OgreCubeMapRenderingRun*) (run->asOgreRenderingRun());
	
	if(getMinMax)
	{
		if(minVariableName != "")
			pass->getFragmentProgramParameters()->setNamedConstant(minVariableName, cuberun->getMin());
		if(maxVariableName != "")
			pass->getFragmentProgramParameters()->setNamedConstant(maxVariableName, cuberun->getMax());
	}
}

RenderingRun* OgreCubeMapRenderTechnique::createCubeMapRun()
{
	return new OgreCubeMapRenderingRun( (OgreSharedRuns*) parentTechniqueGroup->getSharedRuns(), 
												parentOgreRenderable->getName()  + texturePostFix,
												startFrame,
												cubeMapUpdateInterval,
												cubeMapResolution,
												useDistCalc,
												useFaceAngleCalc,
												distTolerance,
												angleTolerance,
												updateAllFace,
												renderSelf,
												renderEnvironment,
												selfMaterial,
												environmentMaterial,
												triggerName,
												getMinMax,
												cubemapLayer);
}

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

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

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

	void parseUseDistCalc(String& params, RenderTechniqueFactory* factory)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) 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)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) 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)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
		f->updateAllFace =  StringConverter::parseBool(params);
	}

	void parseRenderSelf(String& params, RenderTechniqueFactory* factory)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
		f->renderSelf =  StringConverter::parseBool(params);
	}

	void parseRenderEnv(String& params, RenderTechniqueFactory* factory)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
		f->renderEnvironment =  StringConverter::parseBool(params);
	}

	void parseSelfMaterial(String& params, RenderTechniqueFactory* factory)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
		f->selfMaterial =  params;
	}

	void parseEnvMaterial(String& params, RenderTechniqueFactory* factory)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
		f->environmentMaterial =  params;
	}

	void parseMinVarName(String& params, RenderTechniqueFactory* factory)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
		f->minVariableName =  params;
	}
	void parseMaxVarName(String& params, RenderTechniqueFactory* factory)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
		f->maxVariableName =  params;
	}

	void parseLayer(String& params, RenderTechniqueFactory* factory)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
		f->layer =  StringConverter::parseInt(params);
	}

	void parseGetMinMax(String& params, RenderTechniqueFactory* factory)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
		f->getMinMax =  StringConverter::parseBool(params);
	}

	void parseAttachTexUnit(String& params, RenderTechniqueFactory* factory)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
		f->attachToTexUnit =  StringConverter::parseBool(params);
	}

	void parseTriggerName(String& params, RenderTechniqueFactory* factory)
	{
		OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
		f->triggerName =  params;
	}

}
///Technique factory
OgreCubeMapRenderTechniqueFactory::OgreCubeMapRenderTechniqueFactory()
{
	typeName = "CubeMap";

	using namespace CubemapParsers;

	//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("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));
	this->attributeParsers.insert(AttribParserList::value_type("render_self", (ILLUM_ATTRIBUTE_PARSER) parseRenderSelf));
	this->attributeParsers.insert(AttribParserList::value_type("render_env", (ILLUM_ATTRIBUTE_PARSER) parseRenderEnv));
	this->attributeParsers.insert(AttribParserList::value_type("self_material", (ILLUM_ATTRIBUTE_PARSER) parseSelfMaterial));
	this->attributeParsers.insert(AttribParserList::value_type("env_material", (ILLUM_ATTRIBUTE_PARSER) parseEnvMaterial));
	this->attributeParsers.insert(AttribParserList::value_type("layer", (ILLUM_ATTRIBUTE_PARSER) parseLayer));
	this->attributeParsers.insert(AttribParserList::value_type("get_minmax", (ILLUM_ATTRIBUTE_PARSER) parseGetMinMax));
	this->attributeParsers.insert(AttribParserList::value_type("attach_to_texture_unit", (ILLUM_ATTRIBUTE_PARSER) parseAttachTexUnit));
	this->attributeParsers.insert(AttribParserList::value_type("min_var_name", (ILLUM_ATTRIBUTE_PARSER) parseMinVarName));
	this->attributeParsers.insert(AttribParserList::value_type("max_var_name", (ILLUM_ATTRIBUTE_PARSER) parseMaxVarName));
	this->attributeParsers.insert(AttribParserList::value_type("trigger_name", (ILLUM_ATTRIBUTE_PARSER) parseTriggerName));

}

void OgreCubeMapRenderTechniqueFactory::resetParams()
{
	startFrame = 1;
	cubeMapUpdateInterval = 1;
	cubeMapResolution = 256;												
	texID = 0;
	useDistCalc = 1;
	useFaceAngleCalc = false;
	distTolerance = 2.0;
	angleTolerance = 2.0;
	updateAllFace = false;
	renderSelf = false;
	renderEnvironment = true;
	selfMaterial = "";
	environmentMaterial = "";
	layer = 0;
	getMinMax = false;
	attachToTexUnit = true;
	minVariableName = "";
	maxVariableName = "";
	triggerName = "";

}

OgreRenderTechnique* OgreCubeMapRenderTechniqueFactory::createInstance( 
										IllumTechniqueParams* params,
										Pass* pass,
										OgreRenderable* parentRenderable,
										OgreTechniqueGroup* parentTechniqueGroup)
{	
	resetParams();
	parseParams(params);
	
	OgreCubeMapRenderTechnique* result = new OgreCubeMapRenderTechnique(
												startFrame,
												cubeMapUpdateInterval,
												cubeMapResolution,
												texID,
												useDistCalc,
												useFaceAngleCalc,
												distTolerance,
												angleTolerance,
												updateAllFace,
												renderSelf,
												renderEnvironment,
												selfMaterial,
												environmentMaterial,
												layer,
												getMinMax,
												attachToTexUnit,
												minVariableName,
												maxVariableName,
												triggerName,
												pass,
												parentRenderable,
												parentTechniqueGroup,
												true);

	return result;
}