#include "OgreChildPSystemRenderingRun.h"
#include "OgreIlluminationManager.h"

OgreChildPSystemRenderingRun::OgreChildPSystemRenderingRun(OgreSharedRuns* sharedRuns,
															String name,
															unsigned long startFrame,
															unsigned long updateInterval,
															unsigned int resolution,
															bool perspectiveRendering,
															String childParticleSystemName,
															String particleScriptName,
															bool useOwnMaterial,
															String materialName)
														   :ChildPsystemRenderingRun(resolution, perspectiveRendering, startFrame, updateInterval)
														   , OgreRenderingRun(startFrame, updateInterval)
														   , RenderingRun(startFrame, updateInterval)
{
	this->sharedRuns = sharedRuns;
	this->name = name;	
	this->resolution = resolution;
	this->materialName = materialName;
	this->particleScriptName = particleScriptName;
	this->perspectiveRendering = perspectiveRendering;
	this->childParticleSystemName = childParticleSystemName;
	this->useOwnMaterial = useOwnMaterial;
	createImpostorTexture();	
}

void OgreChildPSystemRenderingRun::createImpostorTexture()
{
	TexturePtr texPtr = Ogre::TextureManager::getSingleton().createManual(name, 
																		"default",
																		TEX_TYPE_2D,
																		resolution,
																		resolution,
																		0,
																		0,
																		PF_FLOAT16_RGBA,
																		TU_RENDERTARGET);
	 impostorTexture = texPtr.getPointer();
	 impostorCamera = Root::getSingleton()._getCurrentSceneManager()->createCamera(name + "_CAMERA");
	 //add viewport to rendertarget
	 HardwarePixelBuffer* hpb = (impostorTexture->getBuffer()).getPointer();
	 RenderTarget* rt = hpb->getRenderTarget();
	 Viewport* v = rt->addViewport(impostorCamera);
	 //Viewport* v = rt->addViewport(OgreIlluminationManager::getSingleton().getMainCamera());
	 v->setBackgroundColour(ColourValue(0,0,0,0));
	 v->setOverlaysEnabled(false);
	 rt->setAutoUpdated(false);
}

void OgreChildPSystemRenderingRun::updateFrame(unsigned long frameNum)
{
	
	Material* mat = (Material*) MaterialManager::getSingleton().getByName(materialName).getPointer();

    SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
	RenderQueue* rq = sm->getRenderQueue();
	rq->clear();

	sharedRuns->getRoot()->updateBounds();
	Vector3 center = sharedRuns->getRootPosition(ILLUMRUN_HPP_IMPOSTOR);
	Camera* mainCam = OgreIlluminationManager::getSingleton().getMainCamera();
	impostorCamera->setPosition(mainCam->getPosition());
	
//	psysNode->setPosition(center);
	ParticleSystem* psys = Root::getSingleton()._getCurrentSceneManager()->getParticleSystem(childParticleSystemName);
	
	psysNode->_updateBounds();
	AxisAlignedBox bb = psysNode->_getWorldAABB();	
	
	float r = (bb.getMaximum() - bb.getMinimum()).length() / 2.0;
	sysRad = r;
	center = bb.getCenter();
	//Vector3 dir = center - mainCam->getPosition();
	Vector3 dir = mainCam->getDirection();
	float d = dir.normalise();
	
	if (d <= r * 1.2)//too close
	{
		d = r * 1.2;
		impostorCamera->setPosition(dir * -d);
	}

    impostorCamera->setDirection(dir);

	//r = 200;
	
	if(perspectiveRendering)
	{
		impostorCamera->setProjectionType(PT_PERSPECTIVE);
		impostorCamera->setAspectRatio(1.0);
		Radian a = Math::ASin(r / d) * 2.0;
		impostorCamera->setFOVy( a );
		impostorCamera->setNearClipDistance(d - r);
		impostorCamera->setFarClipDistance(d + r);		
	}
	else
	{
		impostorCamera->setPosition(Vector3(0,0,0));
		impostorCamera->setProjectionType(PT_ORTHOGRAPHIC);
		Matrix4 m;
		m = Matrix4::IDENTITY;
		float scale = 1.0 / r;
		m.setScale(Vector3(scale, scale, scale));
		impostorCamera->setCustomProjectionMatrix(true, m);
	}	

	//
	psys->_notifyCurrentCamera(impostorCamera);
	psys->_updateRenderQueue(rq);
	
	if(!useOwnMaterial)
		setMaterialForRenderables(materialName,rq);
	
	RenderTarget* rt = impostorTexture->getBuffer().getPointer()->getRenderTarget();
	sm->setFindVisibleObjects(false);
	rt->update();	
	sm->setFindVisibleObjects(true);
	
	
	static int framecount = 0;
	String filename = "impostor_";
	filename.append(this->name);
	//filename.append(StringConverter::toString(framecount));
	filename.append(".bmp");
	//rt->writeContentsToFile(filename);
	framecount++;	
	
	if(!useOwnMaterial)
		restoreMaterials();
}

void OgreChildPSystemRenderingRun::freeAllResources()
{
	impostorTexture = 0;
	TextureManager::getSingleton().remove(name);
	Root::getSingleton()._getCurrentSceneManager()->destroyCamera(name + "_CAMERA");	
}