path: root/src/model/parts.h

/*
   model/classes.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_MODEL_PARTS_H__
#define __INCLUDED_MODEL_PARTS_H__

#include "math/axis.h"
#include "math/color.h"
#include "math/vector3f.h"

namespace model
{

/* ---- globals ---------------------------------------------------- */

// FIXME this should end up in material.h

/**
 * @brief
 * culling parameter values
 * Culling is a paremeter used by flares and particles to indicate
 * with side of the polygons should be culled during rendering
 */
enum Cull { CullNone=0, CullBack=1, CullFront=2 };

/* ---- class Part ------------------------------------------------- */

/**
 * @brief a special part of a model
 */
class Part
{
public:
	/**
	 * @brief default constructor
	 */
	inline Part() : part_location()
	{
	}

	/**
	 * @brief copy constructor
	 */
	inline Part(const Part& other) : part_location(other.location())
	{
	}

	/**
	 * @brief constructor with location
	 * @param location location of this part within the parent model
	 */
	inline Part(const math::Vector3f& location) : part_location(location)
	{
	}

	/* ---- inspectors ----------------------------------------- */

	/**
	 * @brief location of this part within the parent model
	 */
	inline const math::Vector3f& location() const
	{
		return part_location;
	}

	/* ---- mutators ------------------------------------------- */
	/**
	 * @brief set the location within the parent model
	 */
	inline void set_location(const math::Vector3f& location) { part_location.assign(location); }

	/**
	 * @brief set the location within the parent model
	 */
	inline void set_location(const float x, const float y, const float z) { part_location.assign(x, y, z); }

	/* ---- actors --------------------------------------------- */

	/**
	 * @brief mutable reference to the location of this part within the parent model
	 */
	inline math::Vector3f& get_location()
	{
		return part_location;
	}	

private:
	math::Vector3f		part_location;
};

/* ---- class Light ------------------------------------------------ */

/// an exterior light
class Light : public Part
{
public:
	/**
	 * @brief default constructor
	 */
	Light();

	/**
	 * @brief copy constructor
	 */
	Light(const Light& other);

	/**
	 * @brief destructor
	 */
	~Light();
	
	/* ---- inspectors ----------------------------------------- */

	/// light color
	inline const math::Color& color() const
	{
		return light_color;
	};
	
	/// true if this is a strobe light
	inline bool strobe() const
	{
		return light_strobe;
	}
	
	/// true if this light has entity color
	inline bool entity() const
	{
		return light_entity;
	}

	/// true if this light has engine activation
	inline bool engine() const
	{
		return light_engine;
	}
	
	/// size of the light, default is 1.0f
	inline float radius() const
	{
		return light_radius;
	}
	
	/// strobe time offset, in seconds
	inline float offset() const
	{
		return light_offset;
	}
	
	/// strobe frequency in strobes per second, default is 1.0f
	inline float frequency() const
	{
		return light_frequency;
	}
	
	/// fraction a strobe light will be on, default is 0.5f
	inline float time() const
	{
		return light_time;
	}
	
	/// flare texture number
	inline unsigned int flare() const
	{
		return light_flare;
	}
	
	/// render texture id
	inline size_t texture() const
	{
		return light_texture;
	}
	/* ---- mutators ------------------------------------------- */

	/**
	 * @brief set strobe color on or off
	 */
	inline void set_strobe(const bool strobe) { light_strobe = strobe; }

	/**
	 * @brief set entity color on or off
	 */
	inline void set_entity(const bool entity) { light_entity = entity; }

	/**
	 * @brief set engine activation on or off
	 */
	inline void set_engine(const bool engine) { light_engine = engine; }

	/**
	 * @brief set the light radius
	 */
	inline void set_radius(const float radius) { light_radius = radius; }

	/**
	 * @brief set the light strobe frequency, in strobes per second
	 */
	inline void set_frequency(const float frequency) { light_frequency = frequency; }

	/**
	 * @brief set the light on time, from 0.0 (always off) to 1.0 (always on)
	 */
	inline void set_time(const float time) { light_radius = time; }

	/**
	 * @brief set the light strobe time offset, in seconds
	 */
	inline void set_offset(const float offset) { light_offset = offset; }

	/**
	 * @brief set the flare texture number
	 */
	inline void set_flare(unsigned int flare) { light_flare = flare; }

	/**
	 * @brief set the render texture id
	 */
	inline void set_texture(size_t texture) { light_texture = texture; }

	/**
	 * @brief mutable reference to the color
	 */
	inline math::Color& get_color() { return light_color; }
	
private:
	bool			light_strobe;
	bool			light_engine;
	bool			light_entity;

	unsigned int		light_flare;

	float			light_radius;
	float			light_frequency;
	float			light_offset;
	float			light_time;

	math::Color		light_color;

	size_t			light_texture;
};

/* ---- class Flare ------------------------------------------------ */

/// a flare is a directional light
class Flare : public Light
{
public:
	Flare();

	/**
	 * @brief copy constructor
	 */
	Flare(const Flare& other);

	~Flare();
	
	/* ---- inspectors ----------------------------------------- */

	inline const math::Axis &axis() const
	{
		return flare_axis;
	}
	
	inline Cull cull() const
	{
		return flare_cull;
	}

	/* ---- mutators ------------------------------------------- */
	
	inline void set_cull(const Cull cull) { flare_cull = cull; }

	/* ---- actors --------------------------------------------- */

	/**
	 * @brief mutable reference to the axis
	 */
	inline math::Axis& get_axis() { return flare_axis; }

private:
	Cull			flare_cull;
	math::Axis		flare_axis;
};

/* ---- class Particles -------------------------------------------- */

/// a particle system
class Particles : public Part
{
public:
	Particles();

	Particles(const math::Vector3f & location);

	~Particles();
	
	inline const math::Axis &axis() const
	{
		return particles_axis;
	}
	
	inline const std::string&  script() const
	{
		return particles_script;
	}

	inline bool entity() const
	{
		return particles_entity;
	}

	inline bool engine() const
	{
		return particles_engine;
	}
	
	inline float radius() const
	{
		return particles_radius;
	}

	inline Cull cull() const
	{
		return particles_cull;
	}

	/* ---- mutators ------------------------------------------- */

	/**
	 * @brief set entity color on or off
	 */
	inline void set_entity(const bool entity) { particles_entity = entity; }

	/**
	 * @brief set engine activation on or off
	 */
	inline void set_engine(const bool engine) { particles_engine = engine; }

	inline void set_radius(const float radius) { particles_radius = radius;	}

	inline void set_cull(const Cull cull) { particles_cull = cull; }

	inline void set_script(const std::string& script) { particles_script.assign(script); }

	/* ---- actors --------------------------------------------- */

	/**
	 * @brief mutable reference to the axis
	 */
	inline math::Axis& get_axis() { return particles_axis; }

private:
	bool			particles_entity;
	bool			particles_engine;

	Cull			particles_cull;

	float			particles_radius;

	math::Axis		particles_axis;	
	std::string		particles_script;
};

/* ---- class Dock ------------------------------------------------- */

/// a docking location
class Dock : public Part
{
public:
	Dock();

	/**
	 * @brief copy constructor
	 */
	Dock(const Dock& other);

	~Dock();
	
	/// dock radius, default is 0.01f
	inline float radius() const
	{
		return dock_radius;
	}

	/// set dock radius	
	inline void set_radius(const float radius) { dock_radius = radius; }	

private:
	float			dock_radius;
};

/* ---- class SubModel --------------------------------------------- */

/// a submodel
class SubModel : public Part
{
public:
	SubModel();

	SubModel(const SubModel& other);

	~SubModel();

	inline const std::string& name() const { return submodel_name; }

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

	inline float scale() const { return submodel_scale; }


	inline void set_scale(const float scale) { submodel_scale = scale; }

	inline void set_name(const std::string& name) { submodel_name.assign(name); }

	inline void set_axis(const math::Axis& axis) { submodel_axis.assign(axis); }

	/* ---- actors --------------------------------------------- */

	/**
	 * @brief mutable reference to the axis
	 */
	inline math::Axis& get_axis() { return submodel_axis; }

private:
	float			submodel_scale;
	std::string		submodel_name;
	math::Axis		submodel_axis;
};

}

#endif // __INCLUDED_MODEL_PARTS_H__