#include "OgreDistanceCubeMapRenderingRun.h"
#include "OgreIlluminationManager.h"



OgreDistanceCubeMapRenderingRun::OgreDistanceCubeMapRenderingRun(OgreSharedRuns* sharedRuns,
														   String name,
														   unsigned long startFrame,
															unsigned long updateInterval,
															unsigned int resolution,
														   bool useDistCalc,
														   bool useFaceAngleCalc,
														   float distTolerance,
														   float angleTolerance,
														   bool updateAllFace)
					:DistanceCubeMapRenderingRun(startFrame, updateInterval, resolution, useDistCalc, useFaceAngleCalc, distTolerance, angleTolerance, updateAllFace)
					, OgreRenderingRun(startFrame, updateInterval)
					, RenderingRun(startFrame, updateInterval)
{
	this->sharedRuns = sharedRuns;
	this->name = name;
	
	createDistanceCubeMap();
}

void OgreDistanceCubeMapRenderingRun::createDistanceCubeMap()
{
	distanceCubemapTexture = createCubeRenderTexture(name, 
							sharedRuns->getRootPosition(),
												resolution,
												PF_FLOAT32_RGBA);
}

void OgreDistanceCubeMapRenderingRun::updateCubeFace(int facenum)
{
	sharedRuns->getRoot(ILLUMRUN_DISTANCE_CUBEMAP)->hide();

	RenderTarget* rt = distanceCubemapTexture->getBuffer(facenum, 0).getPointer()
							->getRenderTarget();

	Vector3 center = sharedRuns->getRootPosition(ILLUMRUN_DISTANCE_CUBEMAP);
	Camera*  cam = 	rt->getViewport(0)->getCamera();
	cam->setPosition(center);

	
	setMaterialForVisibles(String("GameTools/DistanceShader"), cam);

	rt->update();

	restoreMaterials();
	
	//rt->writeContentsToFile("cubbe" + StringConverter::toString(facenum) + ".dds");
	
	sharedRuns->getRoot(ILLUMRUN_DISTANCE_CUBEMAP)->restoreVisibility();
}

bool OgreDistanceCubeMapRenderingRun::faceNeedsUpdate(int facenum)
{	
	if(useDistCalc || useFaceAngleCalc)
	{
		float chance1 = 1.0;
		float chance2 = 1.0;
		
		Camera* mainCamera = OgreIlluminationManager::getSingleton().getMainCamera();

		if(useDistCalc)
		{
			Vector3 cubemapPosition = sharedRuns->getRootPosition(ILLUMRUN_DISTANCE_CUBEMAP);
			float objradius = sharedRuns->getRootBoundingSphere(ILLUMRUN_DISTANCE_CUBEMAP).getRadius();
			float fov = mainCamera->getFOVy().valueRadians() / 2.0;
			float dist = (cubemapPosition - mainCamera->getPosition()).length();
			float vangle = Math::ASin( objradius / dist).valueRadians();
			float angleratio = vangle / fov;
			chance1 = Math::Pow(angleratio, 1.0 / distTolerance);
		}

		if(useFaceAngleCalc)
		{
			Vector3 faceDir = getCubeMapFaceDirection(facenum);			
			Vector3 cameraDir = mainCamera->getDirection();
			float angle = faceDir.dotProduct(-1 * cameraDir);
			float facingforward = (angle + 1) / 2.0;
			chance2 = Math::Pow(facingforward, 1.0 / angleTolerance);
		}
	
		float dice = Math::UnitRandom();
		float chance = chance1 * chance2;

		if(dice < chance)
		{	
			return true;
		}
		else
		{
			return false;
		}
	}

	return true;
}