#pragma once
#include <My3DGraphRes\ParticleSystem.h>
#include <My3DGraphRes\Camera.h>
#include <My3DGraphRes\Impostor.h>
#include <My3DGraphRes\Texture.h>
#include <includes.h>
#include <glh/glh_extensions.h>
#include <MyCgRes\CgProgram.h>
#include <RTTRes\RenderTexture.h>

/**
	@brief This class represents a particle system that uses the Illumination Networks technique.
	
	This particle system can be lit with two dinamic directional light sources and a sky light color.
	The direction and color of the light sources can freely change.
*/
class PreIllumSystem
{
public:
	PreIllumSystem(void)
	{
		m_IterateCount=0;
		m_Symmetry=0.0;
		m_Albedo=0.9;
		m_Opacity=0.5;
		m_LightWindowSize=64;
		m_LRendVisMap=NULL;
	}

	~PreIllumSystem(void);
	
	/**
		@brief a system that stores particle positions and can render them as sprites
	*/
	ParticleSystem m_System;
	/**
		@brief the number of directions the technique should use
	*/
	int m_DirectionCount;
	/**
		@brief the number of particles in the system
	*/
	int m_ParticleCount;
	/**
		@brief the albedo of one particle
	*/
	float m_Albedo;
	/**
		@brief the desirer opacity of the medium
	*/
	float m_Opacity;
	/**
		@brief the symmetry of scattering used in the phase function
	*/
	float m_Symmetry;
	/**
		@brief resolution of the lightsources viewports
	*/
	int m_LightWindowSize;
	/**
		@brief number of iterations in a frame

		As the result of the last frame is used, this should be set to one.
	*/	
	int m_IterateCount;

private:

	/**
		@brief color of the sky
	*/
	Vector m_SkyColor;
	/**
		@brief used for fullscreen quad rendering
	*/
	Impostor m_ScreenQuad;
	Impostor m_CameraImpostor;
	Impostor m_LightImpostor;
	
	/**
		@brief view camera
	*/
	Camera *m_EyeCamera;
	Camera m_TempCamera;
	/**
		@brief position of the first lightsource
	*/
	Vector m_LightPosition;
	/**
		@brief color of the first lightsource
	*/
	Vector m_LightColor;
	/**
		@brief position of the second lightsource
	*/
	Vector m_LightPosition2;
	/**
		@brief color of the second lightsource
	*/
	Vector m_LightColor2;
	/**
		@brief the closest direction from the predefined directions to the light's direction
	*/
	int m_NearestDir;
	/**
		@brief the second closest direction from the predefined directions to the light's direction
	*/
	int m_NearestDir2;
	/**
		@brief weight of m_NearestDir

		m_NearestDir and m_NearestDir2 will be interpolated
	*/
	float m_Weight1;
	/**
		@brief weight of m_NearestDir2

		m_NearestDir and m_NearestDir2 will be interpolated
	*/
	float m_Weight2;

	
	// helper members
	Particle* m_ParticleArray;
	float* m_PositionArray;
	float* m_DirectionData;
	Vector* m_Directions;
	float* m_DirectionArray;
	unsigned char* m_LVisMap;
	unsigned char* m_LRendVisMap;
	float* m_Pixels;

	//texture id's
	/**
		@brief stores the visibility information of the particles

		For each particle for each direction the first visible (from that direction) particle's id is stored.
	*/
	GLuint m_VisibilityTexID;
	/**
		@brief stores predefined directions to use
	*/
	GLuint m_DirectionsTexID;
	/**
		@brief a look-up texture to speed up phase function calculation
	*/
	GLuint m_PhaseTextureID;
	/**
		@brief a texture that can be used to determine which particles are visible from the lightsource
	*/
	GLuint m_LVisMapID;
	/**
		@brief used when determining licible particles

		@see FindVisiblesWithRendering
	*/
	GLuint m_RenderedVisID;
	/**
		@brief stores tau value for each particle
	*/
	GLuint m_TauTextureID;
	
	// Cg programs
	CgProgram m_TexRectPrograms;
	CgProgram m_LightIllumPrograms;
	CgProgram m_IllumIteratePrograms;
	CgProgram m_EyeRadPrograms;
	CgProgram m_LVisPrograms;
	CgProgram m_FinalRenderPrograms;
	
	//render textures, textures
	//direct illumination of the lightsource
	RenderTexture m_DirectIlumTexture;
	
	//two illumtextures are used, must ping-pong between them
	RenderTexture m_IllumTexture;
	RenderTexture m_IllumTexture2;
	RenderTexture* m_IllumColorTex;
	RenderTexture* m_IllumRenderTex;
	// radiance to eye
	RenderTexture m_EyeRadTexture;
	RenderTexture m_Target;
	Texture m_BillboardTexture;
	Texture m_Bbtex;	
	//helper
	RenderTexture m_ImpostorTexture;
	
	/**
		@brief generates directions equally along the unit sphere
	*/
	void CreateGivenDirections();
	/**
		@brief generates random directions
	*/
	void CreateRandomDirections(bool fillarray);
	void Calculate_Up_Right_Vector(Vector viewdir,Vector& UpVector,Vector& RightVector);
	/**
		@brief calculates the scattering phase function value for two directions and a symmetry value
	*/
	float Phase(Vector diri,Vector dirj,float symmetry);
	/**
		@brief searches the stored directions and returns the one closest to a given direction
	*/
	GetNearestDirection(Vector LightPosition);
	/**
		@brief Initializator function.
	*/
	void InitSystem(int particlecount,int directioncount);
	/**
		@brief Creates a texture that stores the visibility information of the particles.

		For each particle for each direction the first visible (from that direction) particle's id is stored.
	*/
	void CreateVisibilityTexture();
	/**
		@brief Creates a texture that stores
	*/
	void CreateNearestDirectionTexture();
	/**
		@brief Creates a look-up texture to speed up phase function calculation.
	*/
	void CreatePhaseTexture();
	/**
		@brief Creates a texture that can be used to determine which particles are visible from the lightsource
	*/
	void CreateLVisMap();
	/**
		@brief Creates a texture tha stores the tau value for each particle.

		The tau values are calculated from the given desired opacity and the size of the particle.
	*/
	void CreateTauTexture();
	
	/**
		@brief Refreshes the texture that stores direct illumination information.

		Direct illumination is the amount of light coming directly from the lightsource.
	*/
	void RefreshDirectIllumTexture();
	/**
		@brief Updates the illumination texture.
	*/
	void Iterate();
	/**
		@brief Updates the eye radiance texture.

		The eye radiance texture stores the amount of light headig from each particle to the eye.
	*/
	void CreateEyeRadTexture();
	/**
		@brief Finds the visible particles from a point of view.
	
		The light visibility texture stores the id of the visible particles (with occlusion) from
		the light sources. The param "row" means the id of the lightsource ( 0 or 1).

		The visibility is calculated with rendering the particles from the lightsource. 
		Each particle has a color corresponding it's id. The resulting image is read back, and
		the pixels are counted. If the number of pixels with a particle's id found is greather than
		some limit, the particle is visible.
	*/
	void FindVisiblesWithRendering(Vector LightPosition,int row);
	/**
		@brief not used
	*/
	void RenderToImpostor();
	 
public:
	void SetEyeCamera(Camera* theCam)
	{
		m_EyeCamera=theCam;
		m_CameraImpostor.setViewCamera(theCam);
	}	
	/**
		@brief Initializator function.
	*/
	void Init(int particlecount,int directioncount);
	/**
		@brief Render the particle system.
	*/
	void Display();	
	/**
		@brief Refreshes the system in a frame.

		The actual light positions and colors should be passed.
	*/
	void Refresh(Vector lightpos,Vector lightpos2,Vector lightcolor,Vector lightcolor2);
	/**
		@brief Displays one of the textures used by the system.

		Used for debugging and presentation.
	*/
	char* DisplayTexture(int tex);
	 void getNearest(Vector* positions)
		{	
			positions[0]=m_Directions[m_NearestDir]*3;
			positions[1]=m_Directions[m_NearestDir2]*3;
			
		}
	void IncreaseOpacity()
		{
			m_Opacity+=0.02;
			if(m_Opacity>1)m_Opacity=1;
		}
	void DecreaseOpacity()
		{
			m_Opacity-=0.02;
			if(m_Opacity<0)m_Opacity=0;
		}
	void IncreaseAlbedo()
		{
			m_Albedo+=0.02;
			if(m_Albedo>1)m_Albedo=1;
		}
	void DecreaseAlbedo()
		{
			m_Albedo-=0.02;
			if(m_Albedo<0)m_Albedo=0;
		}
	float getAlbedo(){return m_Albedo;}
	float getOpacity(){return m_Opacity;}
	void ResetIllumTexture()
	{
		m_IllumColorTex->EnablewithColorRelease();
		glClearColor(0,0,0,1);
		glClear(GL_COLOR_BUFFER_BIT);
		m_IllumColorTex->DisablewithColorBind();
	}
	void setSkyColor(Vector skyC){m_SkyColor=skyC;}
};