path: root/src/render/particles.h

/*
   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/tags.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 particlescript_type;
	}

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

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

	inline const math::Color &color() const {
		return particlescript_color;
	}
	
	inline bool has_color() const {
		return particlescript_has_color;
	}
	
	/// axis transformation relative to the ejector
	inline const math::Axis &axis() const {
		return particlescript_axis;
	}

	/// true if entity color is to be applied
	inline bool engine() const {
		return particlescript_engine;
	}
	
	/// true if engine color is to be applied
	inline bool entity() const {
		return particlescript_entity;
	}
	
	inline float radius() const {
		return particlescript_radius;
	}

	inline float timeout() const {
		return particlescript_timeout;
	}

	inline float eject() const {
		return particlescript_eject;
	}

	inline float speed() const {
		return particlescript_speed;
	}

	inline float alpha() const {
		return particlescript_alpha;
	}

	inline float offset() const {
		return particlescript_offset;
	}
	
	inline const model::Cull cull() const {
		return particlescript_cull;
	}

	inline const ParticleScript *next() const {
		return particlescript_next;
	}
	
	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	particlescript_label;
	std::string	particlescript_texture;
	Type		particlescript_type;
	math::Color	particlescript_color;
	math::Axis	particlescript_axis;
	
	bool		particlescript_entity;
	bool		particlescript_engine;
	bool		particlescript_has_color;

	float 		particlescript_radius;
	float		particlescript_timeout;
	float		particlescript_eject;
	float 		particlescript_speed;
	float		particlescript_alpha;
	float		particlescript_offset;
	
	model::Cull	particlescript_cull;
	
	ParticleScript *particlescript_next;

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

	static Registry particlescript_registry;
};

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

/// abstract base class for a particle system attached to an entity
class ParticleSystem
{
public:
	ParticleSystem(const ParticleScript *script, const core::Entity *entity, const 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;
	}
	
	/// color of the particles
	inline const math::Color & color() const {
		return particlesystem_color;
	}

	virtual void draw(const float elapsed);

	void set_timeout(float timeout);

	void set_eject(float eject);

	/// clear all particles
	void clear();

protected:
	typedef std::deque<Particle *> Stream;

	inline Stream & stream() {
		return particlesystem_stream;
	}
	Stream		particlesystem_stream;
	
	math::Axis	particlesystem_axis;
	math::Vector3f	particlesystem_location;
	math::Vector3f  ejector_location;
	math::Color	particlesystem_color;
	model::Cull	particlesystem_cull;
	
	
	bool		ejector_active;
	float		particlesystem_last_eject;
	float		particlesystem_radius;
	float		now;

	size_t		particlesystem_texture;

	const model::Particles 	*particlesystem_modelclass;
	const ParticleScript	*particlesystem_script;
	const core::Entity	*particlesystem_entity;
};

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

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

	virtual void draw(const float elapsed);
};

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

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

	virtual void draw(const float elapsed);
};

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

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

	virtual void draw(float elapsed);
};

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

/**
 * @brief spray style particles
 * a spray is a sprite ejector
 * */
class Spray : public ParticleSystem
{
public:
	Spray(const ParticleScript *script, const core::Entity *entity, const model::Particles *modelclass);
	virtual ~Spray();

	virtual void draw(const float elapsed);
};

} // namespace render

#endif // __INCLUDED_RENDER_PARTICLES_H__