Subversion Repositories gelsvn

#ifndef __IMESH_TRIMESH_H__

#define __IMESH_TRIMESH_H__

#include <iostream>

#include "AttrVec.h"

namespace IMesh

{

	/** The TriMeshData class represents the data contents of a TriMesh, and

			it also contains almost all of the functions used to set or get values.

			TriMeshData is never used directly, but TriMesh and TriMeshBuilder 

			inherit from this class. */

	class TriMeshData

	{

	private:

		// We do not allow assignment.

		TriMeshData& operator=(const TriMeshData&);

	protected:

		// The following attribute handles contain the attribute numbers

		// of the default face attributes face normals and face colours.

		// If these attributes are unused, the integers are -1

		AttrHandle<CGLA::Vec3f> FA_NORM;

		AttrHandle<CGLA::Vec4f> FA_COL;

		// The following handles contain the attribute numbers of the

		// default vertex attributes: vertex position, normal, colour, and

		// texture coordinates.

		AttrHandle<CGLA::Vec3f> VA_POS;

		AttrHandle<CGLA::Vec3f> VA_NORM; 

		AttrHandle<CGLA::Vec4f> VA_COL;

		AttrHandle<CGLA::Vec4f> VA_TEX;

		/// number of faces.

		int faces_size;

		/// vector of face sets.

		std::vector<FaceSet*> face_sets;

		/// vector of face attribute vectors

		std::vector<AttrVecIf*> face_attr;

		/// Mapping from vertex attribute to face set.

		std::vector<int> face_set_mapping;

		/// vector of vertex attribute vectors.

		std::vector<AttrVecIf*> vert_attr;

		/** Construct an empty instance of TriMesh data. This constructor is used

				by the builder when creating a fresh TriMesh. */

		TriMeshData();

		/** Copy constructor. This is called from the TriMesh constructor when

				the TriMeshBuilder creates a new TriMesh. */

		TriMeshData(const TriMeshData& tmd);

		/** Resets all variables to the values initialized by the constructor

				but it does not remove dynamic memory. */

		void clear();

		/** Remove all dynamice memory used. */

		void clean_up();

	public:

		//----------------------------------------------------------------------

		// Functions that find handles

		//----------------------------------------------------------------------

		/** Get the handle corresponding to a given vertex attribute vector */

		template<class ATTR>

		bool get_vattr_handle(const std::string& name, 

													AttrHandle<ATTR>& handle) const

		{

			for(int i=0;i< vert_attr.size(); ++i)

				{

					if (vert_attr[i]->get_name() == name)

						{

							handle.idx = i;

							return true;

						}

				}

			return false;

		}

		/** Get the handle corresponding to a given face attribute vector */

		template<class ATTR>

		bool get_fattr_handle(const std::string& name, 

													AttrHandle<ATTR>& handle) const

		{

			for(int i=0;i< face_attr.size(); ++i)

				{

					if (face_attr[i]->get_name() == name)

						{

							handle.idx = i;

							return true;

						}

				}

			return false;

		}

				// The following functions return the number of faces, vertices, and attributes.

		/// Returns the number of faces

		int no_faces() const 

		{

			return faces_size;

		}

		/// Return the number of vertex attributes associated with the attribute handles

		template<class ATTR>

		int no_vattrib(const AttrHandle<ATTR>& handle) const 

		{

			assert(handle.idx>=0);

			return vert_attr[handle.idx]->size();

		}

		/// Return the number of vertices.

		int no_vertices() const 

		{

			return no_vattrib(VA_POS);

		}

		/// Return the number of vertex normals.

		int no_vnorm() const

		{

			if(VA_NORM.idx >=0)

				return no_vattrib(VA_NORM);

			return 0;

		}

		/// Return the number of vertex colours

		int no_vcol() const

		{

			if(VA_COL.idx >=0)

				return no_vattrib(VA_COL);

			return 0;

		}

		/// Return the number of vertex texture coords

		int no_vtex() const

		{

			if(VA_TEX.idx >=0)

				return no_vattrib(VA_TEX);

			return 0;

		}

		//----------------------------------------------------------------------

		// Set functions

		//----------------------------------------------------------------------

		/** Set face. The arguments are the face set, the face index and a Vec3i

				containing the three indices. */

		CGLA::Vec3i& face(int fidx, int face_set=0)

		{

			assert(fidx < face_sets[face_set]->size());

			return (*face_sets[face_set])[fidx];

		}

		/** Template function used to set a face attribute. The template argument

				is the attribute type. The arguments are the atttribute number, 

				the face index, and the value. */

		template<class ATTR>

		ATTR& fattr(AttrHandle<ATTR> handle, int fidx)

		{

			return attr<ATTR>(*face_attr[handle.idx],fidx);

		}

		/** Template function used to set a vertex attribute. The template

				argument is the attribute type. The arguments are the attribute

				number, the index of a face, the corresponding corner, and the

				value of the attribute belonging to the thus specified vertex. */

		template<class ATTR>

		ATTR& vattr(AttrHandle<ATTR> handle, int fidx, int crnr)

		{

			int face_set = face_set_mapping[handle.idx];

			int vidx = (*face_sets[face_set])[fidx][crnr];

			return attr<ATTR>(*vert_attr[handle.idx],vidx);

		}

		/** Template function used to set a vertex attribute. The template

				argument is the type of the attribute, and the arugments are the

				attribute number,	the vertex index, and the value. */

		template<class ATTR>

		ATTR& vattr(AttrHandle<ATTR> handle, int vidx)

		{

			return attr<ATTR>(*vert_attr[handle.idx],vidx);

		}

		//----------------------------------------------------------------------

		// Get functions

		//----------------------------------------------------------------------

		/** Get a face. Returns a Vec3i with the face's corner indices.

				The arguments are the "face set" and the face index. */

		const CGLA::Vec3i face(int fidx,int face_set=0) const 

		{

			assert(fidx < face_sets[face_set]->size());

			return (*face_sets[face_set])[fidx];

		}

		/// Template function that gets face attribute.

		template<class ATTR>

		const ATTR& fattr(AttrHandle<ATTR> handle, int fidx) const

		{

			return attr<ATTR>(*face_attr[handle.idx],fidx);

		}

		/// Template function that gets vertex attribute from face index and corner

		template<class ATTR>

		const ATTR& vattr(AttrHandle<ATTR> handle, int fidx, int crnr) const

		{

			int face_set = face_set_mapping[handle.idx];

			int vidx = (*face_sets[face_set])[fidx][crnr];

			return attr<ATTR>(*vert_attr[handle.idx],vidx);

		}

		/// Get vertex attribute from vertex index

		template<class ATTR>

		const ATTR& vattr(AttrHandle<ATTR> handle, int vidx) const

		{

			return attr<ATTR>(*vert_attr[handle.idx],vidx);

		}

		// ----------------------------------------------------------------------

		// Utility functions for getting and setting the face normal

		// ----------------------------------------------------------------------

		/// Set a face normal

		const CGLA::Vec3f& fnorm(int fidx)

		{

			return fattr(FA_NORM, fidx);

		}

		/// Get a face normal

		const CGLA::Vec3f& fnorm(int fidx) const

		{

			return fattr(FA_NORM, fidx);

		}

		// ----------------------------------------------------------------------

		// Utility functions for getting and setting the face colour

		// ----------------------------------------------------------------------

		/// Set a face colour

		CGLA::Vec4f& fcol(int fidx)

		{

			return fattr(FA_COL, fidx);

		}

		/// Get a face colour

		const CGLA::Vec4f& fcol(int fidx) const

		{

			return fattr(FA_COL, fidx);

		}

		// ----------------------------------------------------------------------

		// Utility functions for getting and setting the vertex position

		// ----------------------------------------------------------------------

		/// Set a vertex position using a face index and corner.

		CGLA::Vec3f& vpos(int fidx, int crnr)

		{

			return vattr(VA_POS, fidx, crnr);

		}

		/// Set a vertex position using a direct vertex index

		CGLA::Vec3f& vpos(int vidx)

		{

			return vattr(VA_POS, vidx);

		}

		/// Get a vertex position using a face index and a corner

		const CGLA::Vec3f& vpos(int fidx, int crnr) const

		{

			return vattr(VA_POS, fidx, crnr);

		}

		/// Get a vertex position using a direct index

		const CGLA::Vec3f& vpos(int vidx) const

		{

			return vattr(VA_POS, vidx);

		}

		// ----------------------------------------------------------------------

		// Utility functions for getting and setting the vertex normal

		// ----------------------------------------------------------------------

		/// Set a vertex normal using a face index and corner.

		CGLA::Vec3f& vnorm(int fidx, int crnr)

		{

			return vattr(VA_NORM, fidx, crnr);

		}

		/// Set a vertex normal using a direct vertex index

		CGLA::Vec3f& vnorm(int vidx)

		{

			return vattr(VA_NORM, vidx);

		}

		/// Get a vertex normal using a face index and a corner

		const CGLA::Vec3f& vnorm(int fidx, int crnr) const 

		{

			return vattr(VA_NORM, fidx, crnr);

		}

		/// Get a vertex normal using a direct index

		const CGLA::Vec3f& vnorm(int vidx) const 

		{

			return vattr(VA_NORM, vidx);

		}

		// ----------------------------------------------------------------------

		// Utility functions for getting and setting the vertex colour

		// ----------------------------------------------------------------------

		/// Set a vertex colour using a face index and corner.

		CGLA::Vec4f& vcol(int fidx, int crnr)

		{

			return vattr(VA_COL, fidx, crnr);

		}

		/// Set a vertex colour using a direct vertex index

		CGLA::Vec4f& vcol(int vidx)

		{

			return vattr(VA_COL, vidx);

		}

		/// Get a vertex colour using a face index and a corner

		const CGLA::Vec4f& vcol(int fidx, int crnr) const

		{

			return vattr(VA_COL, fidx, crnr);

		}

		/// Get a vertex colour using a direct index

		const CGLA::Vec4f& vcol(int vidx) const

		{

			return vattr(VA_COL, vidx);

		}

		// ----------------------------------------------------------------------

		// Utility functions for getting and setting the vertex tex coord

		// ----------------------------------------------------------------------

		/// Set a vertex texture coord using a face index and corner.

		CGLA::Vec4f& vtex(int fidx, int crnr)

		{

			return vattr(VA_TEX, fidx, crnr);

		}

		/// Set a vertex texture coord using a direct vertex index

		CGLA::Vec4f& vtex(int vidx)

		{

			return vattr(VA_TEX, vidx);

		}

		/// Get a vertex texture coord using a face index and a corner

		const CGLA::Vec4f& vtex(int fidx, int crnr) const

		{

			return vattr(VA_TEX, fidx, crnr);

		}

		/// Get a vertex texture coord using a direct index

		const CGLA::Vec4f& vtex(int vidx) const

		{

			return vattr(VA_TEX, vidx);

		}

	};

	class TriMeshBuilder;

	/** The TriMesh class represents a triangle mesh. It cannot be instantiated

			except by the TriMeshBuilder class. All data and methods are defined

			in the TriMeshData class from which this class inherits. */

	class TriMesh: public TriMeshData

	{

		friend class TriMeshBuilder;

	private:

		// The following constructors are private and undefined. Hence

		// they cannot be used.

		TriMesh(const TriMesh&);

		TriMesh& operator=(const TriMesh&);

		TriMesh();

		// The only legal constructor takes a TriMeshData object as argument

		// This constructor can only be called by the TriMeshBuilder since it

		// us a friend of TriMesh.

		/// Construct a TriMesh from an instance of TriMeshData

		TriMesh(const TriMeshData& tmd): TriMeshData(tmd) {}

		void *data;

	public:

		/// Destructor deletes all attribute vectors. 

		~TriMesh()

		{

			clean_up();

		}

    void get_bsphere(CGLA::Vec3f& c, float& r) const;

    void get_bbox(CGLA::Vec3f& p0, CGLA::Vec3f& p7) const;

		void set_data(void *data) { 

			this->data = data;

		}

		void* get_data() {

			return data;

		}

	};

}

#endif