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 constructor with location
	 */
	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 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 const 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;
	}
	
	/// frequency in strobes per second
	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 number
	inline size_t texture() const
	{
		return render_texture;
	}
	/* ---- mutators ------------------------------------------- */

	/// set strobe on or off
	inline void set_strobe(bool strobe) { light_strobe = strobe; }

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

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


	math::Color		light_color;
	float			light_radius;
	float			light_frequency;
	float			light_offset;
	float			light_time;

	unsigned int		light_flare;

	size_t			render_texture;

private:
	bool			light_strobe;
	bool			light_engine;
	bool			light_entity;
};

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

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

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

	inline const math::Axis axis() const
	{
		return flare_axis;
	}
	
	inline const 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:
	math::Axis		flare_axis;
	Cull			flare_cull;
};

/* ---- 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 const bool entity() const
	{
		return particles_entity;
	}

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

	inline const 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; }
	
	/* ---- actors --------------------------------------------- */

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

	std::string		particles_script;

private:
	math::Axis		particles_axis;	
	float			particles_radius;
	bool			particles_entity;
	bool			particles_engine;
	Cull			particles_cull;
};

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

/// a docking location
class Dock
{
public:
	Dock();
	~Dock();
	
	/// location of the dock
	inline const math::Vector3f & location() const
	{
		return dock_location;
	}
	
	/// trigger distance default is 0.01f
	inline float radius() const
	{
		return dock_radius;
	}
	
	
	math::Vector3f		dock_location;
	float			dock_radius;
};

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

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

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

	inline const float scale() const { return submodel_scale; }

	inline const math::Vector3f &location() const { return submodel_location; }

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

	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_location(const math::Vector3f &location) { submodel_location.assign(location); }

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

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

}

#endif // __INCLUDED_MODEL_PARTS_H__