/*
   render/particles.h
   This file is part of the Osirion project and is distributed under
   the terms of the GNU General Public License version 2
*/

#ifndef __INCLUDED_RENDER_PARTICLES_H__
#define __INCLUDED_RENDER_PARTICLES_H__

#include <deque>

#include "math/axis.h"
#include "math/color.h"
#include "math/vector3f.h"
#include "core/entity.h"
#include "model/parts.h"

namespace render
{

/* ---- class Particle --------------------------------------------- */

/// one particle
class Particle
{
public:
	Particle(const math::Vector3f &location, float time);
	Particle(const math::Vector3f &location, const math::Axis &axis, float time);

	/// location of the particle, in world coordinates
	inline math::Vector3f &location() {
		return particle_location;
	}

	inline math::Axis &axis() {
		return particle_axis;
	}

	inline const float time() const {
		return particle_time;
	}

protected:
	math::Vector3f	particle_location;
	math::Axis  	particle_axis;

	float		particle_time;
};

/* ---- class ParticleScript --------------------------------------- */

/// class to hold particle scripts
class ParticleScript
{
public:

	enum Type {Jet = 0, Trail = 1, Flame = 2, Spray = 3 };

	inline const Type type() const {
		return particles_type;
	}

	inline const std::string &label() const {
		return particles_label;
	}

	inline const std::string &texture() const {
		return particles_texture;
	}

	inline const math::Color &color() const {
		return particles_color;
	}

	inline float radius() const {
		return particles_radius;
	}

	inline float timeout() const {
		return particles_timeout;
	}

	inline float eject() const {
		return particles_eject;
	}

	inline float speed() const {
		return particles_speed;
	}

	inline float alpha() const {
		return particles_alpha;
	}

	inline float offset() const {
		return particles_offset;
	}

	static ParticleScript *load(const std::string &label);

	static void clear();

	static void list();
private:
	static ParticleScript *find(const std::string &label);

	ParticleScript(const std::string label);
	~ParticleScript();

	std::string	particles_label;
	std::string	particles_texture;
	Type		particles_type;
	math::Color	particles_color;

	float 		particles_radius;
	float		particles_timeout;
	float		particles_eject;
	float 		particles_speed;
	float		particles_alpha;
	float		particles_offset;

	typedef std::map<std::string, ParticleScript *> Registry;

	static Registry particles_registry;
};

/* ---- class ParticleSystem --------------------------------------- */

/// abstract base class for a particle system attached to an entity
class ParticleSystem
{
public:
	ParticleSystem(ParticleScript *script, core::Entity *entity, model::Particles *modelclass);
	virtual ~ParticleSystem();

	/// index of the texture to use
	inline const size_t texture() const {
		return particlesystem_texture;
	}

	/// location of the particle system within the entity
	inline const math::Vector3f &location() const {
		return particlesystem_location;
	}

	/// axis of the particle system within the entity
	inline const math::Axis &axis() const {
		return particlesystem_axis;
	}

	inline const model::Cull cull() const {
		return particlesystem_cull;
	}

	virtual void draw(float elapsed);

	void set_timeout(float timeout);

	void set_eject(float eject);

	/// clear all particles
	void clear();

protected:
	core::Entity	*particlesystem_entity;

	typedef std::deque<Particle *> Stream;

	inline Stream & stream() {
		return particlesystem_stream;
	}

	size_t		particlesystem_texture;

	math::Axis	particlesystem_axis;
	math::Vector3f	particlesystem_location;

	float		particlesystem_last_eject;

	ParticleScript	*particlesystem_script;

	Stream		particlesystem_stream;

	math::Vector3f  ejector_location;
	bool		ejector_active;
	float		particlesystem_radius;
	float		now;
	math::Color	color;

	model::Particles *particlesystem_modelclass;
	model::Cull	particlesystem_cull;
};

/* ---- class Flame ------------------------------------------------ */

/// flame style particles, like engine flames
class Flame : public ParticleSystem
{
public:
	Flame(ParticleScript *script, core::Entity *entity, model::Particles *modelclass);
	virtual ~Flame();

	virtual void draw(float elapsed);
};

/* ---- class Jet -------------------------------------------------- */

/// jet style particles, like smoke
class Jet : public ParticleSystem
{
public:
	Jet(ParticleScript *script, core::Entity *entity, model::Particles *modelclass);
	virtual ~Jet();

	virtual void draw(float elapsed);
};

/* ---- class Spray ----------------------------------------------- */

/// spray style particles
class Spray : public ParticleSystem
{
public:
	Spray(ParticleScript *script, core::Entity *entity, model::Particles *modelclass);
	virtual ~Spray();

	virtual void draw(float elapsed);
};

/* ---- class Trail ------------------------------------------------ */

/// trail style particles, like an engine trail
class Trail : public ParticleSystem
{
public:
	Trail(ParticleScript *script, core::Entity *entity, model::Particles *modelclass);
	virtual ~Trail();

	virtual void draw(float elapsed);
};

} // namespace render

#endif // __INCLUDED_RENDER_PARTICLES_H__