#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,
														Pass* pass,
														OgreRenderable* parentRenderable,
														OgreTechniqueGroup* parentTechniqueGroup,
														bool createCubeRun)
							:OgreRenderTechnique( pass, parentRenderable, parentTechniqueGroup),
							CubeMapRenderTechnique(startFrame, cubeMapUpdateInterval, cubeMapResolution, useDistCalc, useFaceAngleCalc, distTolerance, angleTolerance, updateAllFace, renderSelf, renderEnvironment, parentRenderable, parentTechniqueGroup),
							RenderTechnique(parentRenderable, parentTechniqueGroup) 
{	
	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();
	
	pass->getTextureUnitState(texID)->setTextureName(cubemapname);
}

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

///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;
	}
}
///Technique factory
OgreCubeMapRenderTechniqueFactory::OgreCubeMapRenderTechniqueFactory()
{
	
	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));

}

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 = "";
}

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,
												pass,
												parentRenderable,
												parentTechniqueGroup,
												true);

	return result;
}