path: root/src/model/model.h

/*
   model/model.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_MODEL_H__
#define __INCLUDED_MODEL_MODEL_H__

#include <string>
#include <list>
#include <map>

#include "math/mathlib.h"
#include "model/parts.h"
#include "model/fragment.h"

/// classes representing 3D geometry
namespace model
{

/// scaling factor when loading .map geometry
const float SCALE = 1.0f / 1024.0f;
const float LIGHTSCALE =  1.0f / 100.0f;

const float ANGLEUP = -1.0f;
const float ANGLEDOWN = -2.0f;

/// a 3D model contains a list of faces
class Model
{
public:
	/// type definition for the model registry
	typedef std::map<std::string, Model*> Registry;
	
	/// type definition for a list of model fragments
	typedef std::list<Fragment *> Fragments;
	
	/// type definition for a list of model lights
	typedef std::list<Light *> Lights;
	
	/// type definition for a list of model flares
	typedef std::list<Flare *> Flares;
	
	/// type definition for a lost of dockable locations
	typedef std::list<Dock *> Docks;

	/// type definition for a list of model particles
	typedef std::list<Particles *> ParticleSystems;

	/// type definition for a list of FragmentGroups
	typedef std::list<FragmentGroup *> Groups;
	
	/// create a model with a name
	Model(const std::string & name);
	
	/// delete the model, and all fragments, lights, etc
	~Model();
	
	/// the name of the model
	inline const std::string & name() const
	{
		return model_name;
	}
	
	/// radius
	inline float radius() const
	{
		return model_radius;
	}
	
	/// additional model fragment groups
	inline Groups & groups()
	{
		return model_groups;
	}

	/// list of lights
	inline Lights & lights()
	{
		return model_lights;
	}

	/// list of dockable locations
	inline Docks & docks()
	{
		return model_docks;
	}
	
	/// list of flares
	inline Flares & flares()
	{
		return model_flares;
	}
	
	/// list of engines
	inline ParticleSystems & particles()
	{
		return model_particles;
	}
	
	/// maximum values of the bounding box
	inline const math::Vector3f & maxbbox() const
	{
		return model_maxbbox;
	}
	
	/// minimum values of the bounding box
	inline const math::Vector3f & minbbox() const
	{
		return model_minbbox;
	}
	
	/// engine sound loop for this model
	inline unsigned int enginesound() const
	{
		return model_enginesound;
	}

	/// impulse sound set for this model
	inline unsigned int impulsesound() const
	{
		return model_impulsesound;
	}

	/// engine color for this model
	inline const math::Color & enginecolor() const
	{
		return model_enginecolor;
	}

	/// original origin
	inline const math::Vector3f & origin() const
	{
		return model_origin;
	}
	
	/// add a light to the model
	void add_light(Light *light);
	
	/// add a particle system to the model
	void add_particles(Particles *particles);
	
	/// add a flare to the model
	void add_flare(Flare *flare);

	/// add a docking location to the model
	void add_dock(Dock *dock);

	/// add a fragment group to the model
	void add_group(FragmentGroup *group);

	void set_radius(const float radius);

	void set_origin(const math::Vector3f &origin);
	
	math::Vector3f		model_maxbbox;
	math::Vector3f		model_minbbox;
	
	unsigned int		model_enginesound;
	unsigned int		model_impulsesound;

	math::Color		model_enginecolor;
	
	/// total number of  triangles
	size_t			model_tris_count;
	/// number of detail triangles
	size_t			model_tris_detail_count;
	/// total number of quads
	size_t			model_quad_count;
	/// number of detail quads
	size_t			model_quad_detail_count;

	/* ---- static functions for the Model registry -------------------- */
	
	/// the model registry
	static inline Registry & registry()
	{
		return model_registry;
	}
	
	/// get name model, returns 0 if not found
	static Model *find(const std::string & name);
	
	/// get named model from the registry and load it if necessary
	static Model *load(const std::string & name);
	
	/// clear the model registry
	static void clear();
	
	/// list the content of the model registry
	static void list();
	
	/// list one model
	static void list_model(Model *model);

	
private:
	std::string		model_name;

	Docks			model_docks;
	Flares			model_flares;
	Lights			model_lights;
	ParticleSystems		model_particles;
	Groups			model_groups;

	math::Vector3f		model_origin;
	float			model_radius;

	static Registry 	model_registry;
};

}

#endif // __INCLUDED_MODEL_MODEL_H__