#include "OgreCubeMapRenderTechnique.h"
#include "OgreTechniqueGroup.h"
#include "OgreHierarchicalParticleSystemTechnique.h"
#include "OgreChildPSystemRenderingRun.h"

OgreHierarchicalParticleSystemTechnique::OgreHierarchicalParticleSystemTechnique(
														unsigned long startFrame,
														unsigned long impostorUpdateInterval,
														unsigned int impostorResolution,
														unsigned char impostorTexID,
														bool useDistCalc,
														bool perspectiveRendering,
														String childPSysScriptName,
														bool useOwnMaterial,
														String impostorMaterialName,
														Pass* pass,
														OgreRenderable* parentRenderable,
														OgreTechniqueGroup* parentTechniqueGroup)
							:OgreRenderTechnique( pass, parentRenderable, parentTechniqueGroup),
							HierarchicalParticleSystemTechnique(startFrame, impostorUpdateInterval, impostorResolution, useDistCalc, perspectiveRendering, parentRenderable, parentTechniqueGroup),
							RenderTechnique(parentRenderable, parentTechniqueGroup) 
{	
	this->impostorTexID = impostorTexID;
	this->childPSysScriptName = childPSysScriptName;
	this->impostorMaterialName = impostorMaterialName;
	this->useOwnMaterial = useOwnMaterial;
	
	//create the Particle system
	childPSysName = parentOgreRenderable->getName() + "_small_PSYS";
	ParticleSystem* psys = Root::getSingleton()._getCurrentSceneManager()->createParticleSystem(childPSysName, childPSysScriptName);
	SceneNode* node = Root::getSingleton()._getCurrentSceneManager()->getRootSceneNode()->createChildSceneNode();
	node->attachObject(psys);
	psys->setVisible(false);
	
	if(sharedRuns->getRun(ILLUMRUN_HPP_IMPOSTOR) == 0)
		sharedRuns->addRun(ILLUMRUN_HPP_IMPOSTOR, createChildPSysRenderingRun());	

	impostorChanged(sharedRuns->getRun(ILLUMRUN_HPP_IMPOSTOR));
}


OgreHierarchicalParticleSystemTechnique::~OgreHierarchicalParticleSystemTechnique()
{

}

void OgreHierarchicalParticleSystemTechnique::impostorChanged(RenderingRun* run)
{
	OgreChildPSystemRenderingRun* r = (OgreChildPSystemRenderingRun*) run->asOgreRenderingRun();
	pass->getTextureUnitState(impostorTexID)->setTextureName(r->getImpostorTextureName());
}

RenderingRun* OgreHierarchicalParticleSystemTechnique::createChildPSysRenderingRun()
{
	return new OgreChildPSystemRenderingRun( (OgreSharedRuns*) parentTechniqueGroup->getSharedRuns(), 
												parentOgreRenderable->getName()  + "_HPP_IMPOSTOR",
												startFrame,
												impostorUpdateInterval,
												impostorResolution,
												perspectiveRendering,
												childPSysName,
												childPSysScriptName,
												useOwnMaterial,
												impostorMaterialName);
}

///Technique Parsers
namespace HPSParsers
{
	void parseStartFrame(String& params, RenderTechniqueFactory* factory)
	{
		OgreHierarchicalParticleSystemTechniqueFactory* f = (OgreHierarchicalParticleSystemTechniqueFactory*) factory;
		f->startFrame =  StringConverter::parseUnsignedLong(params);
	}
	void parseImpostorUpdateInterval(String& params, RenderTechniqueFactory* factory)
	{
		OgreHierarchicalParticleSystemTechniqueFactory* f = (OgreHierarchicalParticleSystemTechniqueFactory*) factory;
		f->impostorUpdateInterval =  StringConverter::parseUnsignedLong(params);
	}

	void parseImpostorResolution(String& params, RenderTechniqueFactory* factory)
	{
		OgreHierarchicalParticleSystemTechniqueFactory* f = (OgreHierarchicalParticleSystemTechniqueFactory*) factory;
		f->impostorResolution =  StringConverter::parseUnsignedInt(params);
	}

	void parseImpostorTexID(String& params, RenderTechniqueFactory* factory)
	{
		OgreHierarchicalParticleSystemTechniqueFactory* f = (OgreHierarchicalParticleSystemTechniqueFactory*) factory;
		f->impostorTexID =  StringConverter::parseUnsignedInt(params);
	}

	void parseUseDistCalc(String& params, RenderTechniqueFactory* factory)
	{
	/*	OgreHierarchicalParticleSystemTechniqueFactory* f = (OgreHierarchicalParticleSystemTechniqueFactory*) 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;
		}*/
		///TODO
	}

	void parsePerspectiveRendering(String& params, RenderTechniqueFactory* factory)
	{
		OgreHierarchicalParticleSystemTechniqueFactory* f = (OgreHierarchicalParticleSystemTechniqueFactory*) factory;
		f->perspectiveRendering = StringConverter::parseBool(params);
	}
	void parseMaterialName(String& params, RenderTechniqueFactory* factory)
	{
		OgreHierarchicalParticleSystemTechniqueFactory* f = (OgreHierarchicalParticleSystemTechniqueFactory*) factory;
		f->impostorMaterialName = params;
		f->useOwnMaterial = false;
	}
	void parseScriptName(String& params, RenderTechniqueFactory* factory)
	{
		OgreHierarchicalParticleSystemTechniqueFactory* f = (OgreHierarchicalParticleSystemTechniqueFactory*) factory;
		f->childPSysScriptName = params;
	}

	
}
///Technique factory
OgreHierarchicalParticleSystemTechniqueFactory::OgreHierarchicalParticleSystemTechniqueFactory()
{
	typeName = "HPS";

	using namespace HPSParsers;

	//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) parseImpostorUpdateInterval));
	this->attributeParsers.insert(AttribParserList::value_type("resolution", (ILLUM_ATTRIBUTE_PARSER) parseImpostorResolution));
	this->attributeParsers.insert(AttribParserList::value_type("texture_unit_id", (ILLUM_ATTRIBUTE_PARSER) parseImpostorTexID));
	this->attributeParsers.insert(AttribParserList::value_type("distance_calc", (ILLUM_ATTRIBUTE_PARSER) parseUseDistCalc));
	this->attributeParsers.insert(AttribParserList::value_type("perspective", (ILLUM_ATTRIBUTE_PARSER) parsePerspectiveRendering));
	this->attributeParsers.insert(AttribParserList::value_type("particle_script", (ILLUM_ATTRIBUTE_PARSER) parseScriptName));
	this->attributeParsers.insert(AttribParserList::value_type("material", (ILLUM_ATTRIBUTE_PARSER) parseMaterialName));
	
}

OgreRenderTechnique* OgreHierarchicalParticleSystemTechniqueFactory::createInstance( 
										IllumTechniqueParams* params,
										Pass* pass,
										OgreRenderable* parentRenderable,
										OgreTechniqueGroup* parentTechniqueGroup)
{	
	impostorUpdateInterval = 1;
	impostorResolution = 256;
	startFrame = 1;	
	useDistCalc = false;
	impostorTexID = 0;
	perspectiveRendering = true;
	impostorMaterialName = "";
	childPSysScriptName = "";
	bool useOwnMaterial = true;

	parseParams(params);

	OgreHierarchicalParticleSystemTechnique* result = new OgreHierarchicalParticleSystemTechnique(
												startFrame,
												impostorUpdateInterval,
												impostorResolution,
												impostorTexID,
												useDistCalc,
												perspectiveRendering,
												childPSysScriptName,
												useOwnMaterial,
												impostorMaterialName,
												pass,
												parentRenderable,
												parentTechniqueGroup);
	
	return result;
}