Subversion Repositories gelsvn

#ifndef __IMESH_TRIMESHBUILDER_H__

#define __IMESH_TRIMESHBUILDER_H__

#include "TriMesh.h"

namespace IMesh

{

	/** The TriMeshBuilder constructs a TriMesh. The reason to have this

			class is that indexed face sets are very "undynamic" to begin with.

			Typically, we store all data in vectors for efficiency, and it is

			difficult to add and especially remove data from these vectors.

			By having a builder class, we can separate concerns so that the 

			content adding is taken care of before the mesh is used. */

	class TriMeshBuilder: public TriMeshData

	{

		// A TriMeshBuilder is only constructed using the default constructor.

		TriMeshBuilder(const TriMeshBuilder&);

		bool did_call_get_trimesh;

	public:

		/** The constructor begins by registering the basic data

				types, i.e. the */

		TriMeshBuilder();

		~TriMeshBuilder();

		void clear();

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

		// Register face sets and attributes

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

		/** Register a new face set. If this is not the first face set, the 

				first face set is copied into the presently registered face set. */

		int register_face_set();

		/** Register a face attribute of type ATTR. If there is an existing 

				attribute of the same name, then the handle passed as second

				argument is made to point to this attribute and no new attribute

				is created. */

		template<class ATTR>

		void register_face_attribute(const std::string& attr_name,

																 AttrHandle<ATTR>& handle)

		{

			assert(!did_call_get_trimesh);

			if(!get_fattr_handle(attr_name, handle))

				{

					handle.idx = face_attr.size();

					face_attr.push_back(new AttrVec<ATTR>(attr_name));

				}

		}

		/// Utility function, register face colours.

		void register_face_colors();

		/// Utility function that registers the use of face normals.

		void register_face_normals();

		/** Register a vertex attribute of type ATTR, indexed via FACESET.

		If there is an existing attribute of the same name, then the

		handle passed as second argument is made to point to this

		attribute and no new attribute is created. */

		template<class ATTR>

		void register_vertex_attribute(const std::string& attr_name,

																	 AttrHandle<ATTR>& handle, int face_set=0)

		{

			assert(!did_call_get_trimesh);

			assert(face_set < face_sets.size());

			if(!get_vattr_handle(attr_name, handle))

				{

					handle.idx = vert_attr.size();

					vert_attr.push_back(new AttrVec<ATTR>(attr_name));

					face_set_mapping.push_back(face_set);

				}

		}

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

		// utility functions. These are used to register standard resources.

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

		/// Register vertex normals (of type Vec3f)

		void register_vertex_normals(int face_set = 0);

		/// Register vertex normals (of type Vec4f)

		void register_vertex_colors(int face_set = 0);

		/// Register vertex texture coords (of type Vec4f)

		void register_vertex_texcoords(int face_set = 0);

		/** Functions to add a face. When a face is added, the same face

				is added to all facesets. Afterwards, use set_face to alter a face

				in a given face_set. */

		void add_face(const CGLA::Vec3i& face);

		/// Add a vertex attribute

		template<class ATTR>

		int add_vattr(AttrHandle<ATTR> handle, const ATTR& val)

		{

			int n = vert_attr[handle.idx]->size();

			push_back_attr(*vert_attr[handle.idx],val);

			return n;

		}

		/// Add a face attribute

		template<class ATTR>

		int add_fattr(AttrHandle<ATTR> handle, const ATTR& val)

		{

			int n = face_attr[handle.idx]->size();

			push_back_attr(*face_attr[handle.idx],val);

			return n;

		}

		/// Add a face normal

		int add_fnorm(const CGLA::Vec3f& norm)

		{

			return add_fattr(FA_NORM, norm);

		}

		/// Add a face colour

		int add_fcol(const CGLA::Vec4f& col)

		{

			return add_fattr(FA_COL, col);

		}

		/// Add a vertex position to the mesh.

		int add_vpos(const CGLA::Vec3f& pos)

		{

			return add_vattr(VA_POS, pos);

		}

		/// Add a vertex normal to the mesh.

		int add_vnorm(const CGLA::Vec3f& norm)

		{

			return add_vattr(VA_NORM, norm);

		}

		/// Add a vertex colour to the mesh.

		int add_vcol(const CGLA::Vec4f& col)

		{

			return add_vattr(VA_COL, col);

		}

		/// Add a vertex texture coordinate to the mesh.

		int add_vtex(const CGLA::Vec4f& tex)

		{

			return add_vattr(VA_TEX, tex);

		}

		/** Build and return a resource ptr to the trimesh. After this function

				has been called, the destructor is the only function which it is

				allowed to call - unless the clear function is called.  */

		TriMesh* get_trimesh();

	};

	/** Register and compute face normals. if do_flip is true, the normals 

			point opposite the ccw direction. */

	void compute_face_normals(TriMeshBuilder& bldr, bool do_flip=false);

	/** This function computes vertex normals for a mesh. If no vertex normals

			have been registered, compute_vertex_normals will first register and

			add vertex normals. The normals are registered to the default face set

			meaning that there is a one to one relationship between vertices and

			vertex normals. If vertex_normals are already registered, it is assumed

			that the correct number of vertex normals have also been added.

			Vertex normals are then computed by adding the face normal weighted by

			angle to the normal corresponding to each vertex of the face. Finally,

			all vertex normals are normalized. */

	void compute_vertex_normals(TriMeshBuilder& bldr);

	/** This function is passed a builder and the handle of the smoothing group

			attribute. vertex_normals are registered to a new face set, and the 

			normal faces are computed using the smoothing group information. 

			Finally, compute_vertex_normals(bldr) is called to generated the actual

			normals. */

	void compute_vertex_normals(TriMeshBuilder& bldr, 

															AttrHandle<int> smooth_group_attr);

	/** This function is passed a builder and the cosine of a crease angle.

			vertex_normals are registered to a new face set, and the 

			normal faces are computed using the smoothing group information. 

			Finally, compute_vertex_normals(bldr) is called to generated the actual

			normals. */

	void compute_vertex_normals(TriMeshBuilder& bldr, float);

}

#endif