#ifndef NAUTILUS_ADJMODEL_INCLUDED // -*- C++ -*-
#define NAUTILUS_ADJMODEL_INCLUDED

/************************************************************************

  Adjacency model representation.
  $Id: AdjModel.h,v 1.7 1997/07/18 15:27:38 garland Exp $

  Adapted from:
     mlab: (Id: polymodel.h,v 1.13 1997/02/06 16:30:11 garland Exp)
  via
     simplif: (Id: polymodel.h,v 1.1 1997/02/11 15:21:29 garland Exp)

 ************************************************************************/

#include "AdjPrims.h"
#include <gfx/SMF/smf.h>
#include <vector>

namespace simplif
{
	class Model : public SMF_Model
	{
		protected:
			
			vert_buffer vertices;
			edge_buffer edges;
			face_buffer faces;
			vec3_buffer normals; // SUS
			vec2_buffer texcoords;

		private:

			void maybeFixFace(Face *);

		public:
			
			Model()
			{
				validVertCount = 0;
				validEdgeCount = 0;
				validFaceCount = 0;
			}

			~Model()
			{
				for (int i=0; i<vertices.length(); i++)
				{
					delete vertices[i];
				}

				for (int i=0; i<edges.length(); i++)
				{
					delete edges[i];
				}

				for (int i=0; i<faces.length(); i++)
				{
					delete faces[i];
				}
			}

			Bounds bounds;

			int validVertCount;
			int validEdgeCount;
			int validFaceCount;

			//
			// Basic model accessor functions
			//
			simplif::Vertex *vertex(int i) { return vertices(i); }
			simplif::Vec3 & normal(int i){ return normals(i); }
			simplif::Vec2 & texcoord(int i){ return texcoords(i); }
			simplif::Edge *edge(int i) { return edges(i); }
			simplif::Face *face(int i) { return faces(i); }

			int vertCount() { return vertices.length(); }
			int normCount() { return normals.length();  }
			int texcoordCount() { return texcoords.length();  }
			int edgeCount() { return edges.length();    }
			int faceCount() { return faces.length();    }

			vert_buffer& allVertices() { return vertices; }
			edge_buffer& allEdges()    { return edges;    }
			face_buffer& allFaces()    { return faces;    }

			//
			// Simplification primitives
			//
			Vertex   *newVertex(real x=0.0, real y=0.0, real z=0.0);
			Edge     *newEdge(Vertex *,Vertex *);
			Face *newFace(Vertex *, Vertex *, Vertex *);

			void killVertex(Vertex *);
			void killEdge(Edge *);
			void killFace(Face *);

			void reshapeVertex(Vertex *, real, real, real);
			void remapVertex(Vertex *from, Vertex *to);

			void contract(Vertex *v1, Vertex *v2, const Vec3& to,
					face_buffer& changed);

			void contract(Vertex *v1, 
					const vert_buffer& others,
					const Vec3& to,
					face_buffer& changed);

			//
			// Simplification convenience procedures
			//
			void removeDegeneracy(face_buffer& changed);
			void contractionRegion(Vertex *v1, Vertex *v2, face_buffer& changed);
			void contractionRegion(Vertex *v1,
					const vert_buffer& vertices,
					face_buffer& changed);

			//
			// SMF reader functions
			//
			int in_Vertex(const Vec3&);
			int in_Normal(const Vec3&);
			int in_TexCoord(const Vec2&);

			int in_Face(int v1, int v2, int v3, 
									int n1, int n2, int n3,
									int t1, int t2, int t3);

			int miin_Face(int v1, int v2, int v3);

			/*	#ifdef SUPPORT_VCOLOR
					int in_VColor(const Vec3&);
#endif
#ifdef SUPPORT_FCOLOR
int in_FColor(const Vec3&);
#endif
*/
			//
			// Some random functions that are mostly temporary
			//

			Vec3 synthesizeNormal(Vertex *);
	};
}

// NAUTILUS_ADJMODEL_INCLUDED
#endif