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

 *<

	FILE: mesh.h



	DESCRIPTION: Main include file for triangle meshes.



	CREATED BY: Don Brittain



	HISTORY:



 *>	Copyright (c) 1994, All Rights Reserved.

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



#ifndef _MESH_H_



#define _MESH_H_



#include "channels.h"

#include "snap.h"

#include <ioapi.h>

#include "export.h"

#include "vedge.h"  //DS



typedef unsigned short MtlID;



// This a UV coordinate. These cound be Point2s

typedef Point3 UVVert;





#define MESH_MULTI_PROCESSING	TRUE		// TRUE turns on mp vertex transformation



class ISave;

class ILoad;



#define NEWMESH



class RNormal {

	public:

		RNormal()	{ smGroup = mtlIndex = 0; }

		void		setNormal(const Point3 &nor) { normal = nor; }

		void		addNormal(const Point3 &nor) { normal += nor; }	

		void		normalize(void) 	{ normal = Normalize(normal); }

		Point3 &	getNormal(void) 	{ return normal; }

		void		setSmGroup(DWORD g)	{ smGroup = g; }

		void		addSmGroup(DWORD g) { smGroup |= g; }

		DWORD		getSmGroup(void)	{ return smGroup; }

		void		setMtlIndex(MtlID i){ mtlIndex = i; }

		MtlID		getMtlIndex(void)	{ return mtlIndex; }

		void		setRGB(Point3 &clr)	{ rgb = clr; };

		Point3 &	getRGB(void)		{ return rgb; }

		

	private:	

		Point3		normal;	   

		DWORD		smGroup;    

		MtlID		mtlIndex;   

		Point3		rgb;	   

	};					   







// RVertex flags: contain clip flags, number of normals at the vertex

// and the number of normals that have already been rendered.

// fine PLANE_MASK	0x00003f00UL -- now in gfx.h

#define NORCT_MASK			0x000000ffUL

#define SPECIFIED_NORMAL	0x00004000UL

#define OUT_LEFT			0x00010000UL

#define OUT_RIGHT			0x00020000UL

#define OUT_TOP				0x00040000UL

#define OUT_BOTTOM			0x00080000UL

#define RECT_MASK			0x000f0000UL

#define RND_MASK			0xfff00000UL

#define RND_NOR0			0x00100000UL

#define RND_NOR(n)  		(RND_NOR0 << (n))



class RVertex {

	public:

		RVertex()	{ rFlags = 0; ern = NULL; }

		DllExport ~RVertex();	



		DWORD		rFlags;     

		union {

			int		iPos[3];	

			float	fPos[3];

			};

		RNormal		rn;		   

		RNormal 	*ern;		 

	};					  







// Face Flags:

// 		3 LSBs hold the edge visibility flags

// 		Bit 3 indicates the presence of texture verticies



// if bit is 1, edge is visible

#define EDGE_VIS			1

#define EDGE_INVIS			0



// first edge-visibility bit field

#define VIS_BIT				0x0001

#define VIS_MASK			0x0007



#define EDGE_A		(1<<0)

#define EDGE_B		(1<<1)

#define EDGE_C		(1<<2)

#define EDGE_ALL	(EDGE_A|EDGE_B|EDGE_C)



#define FACE_HIDDEN	(1<<3)

#define HAS_TVERTS	(1<<4)

#define FACE_WORK	(1<<5) // used in various algorithms



// The mat ID is stored in the HIWORD of the face flags

#define FACE_MATID_SHIFT	16

#define FACE_MATID_MASK		0xFFFF





class Face {	

	public:

		DWORD	v[3];

		DWORD	smGroup;

		DWORD	flags;



		Face()	{ flags = 0; }

		MtlID	getMatID() {return (int)((flags>>FACE_MATID_SHIFT)&FACE_MATID_MASK);}

		void    setMatID(MtlID id) {flags &= 0xFFFF; flags |= (DWORD)(id<<FACE_MATID_SHIFT);}

		void	setSmGroup(DWORD i) { smGroup = i; }

		DWORD	getSmGroup(void)	{ return smGroup; }

		void	setVerts(DWORD *vrt){ memcpy(v, vrt, 3*sizeof(DWORD)); }

		void	setVerts(int a, int b, int c)  { v[0]=a; v[1]=b; v[2]=c; }

		DllExport void	setEdgeVis(int edge, int visFlag);

		DllExport void    setEdgeVisFlags(int va, int vb, int vc); 

		int		getEdgeVis(int edge){ return flags & (VIS_BIT << edge); }

		DWORD	getVert(int index)	{ return v[index]; }

		DWORD *	getAllVerts(void)	{ return v; }

		BOOL	Hidden() {return flags&FACE_HIDDEN?TRUE:FALSE;}

		void	Hide() {flags|=FACE_HIDDEN;}

		void	Show() {flags&=~FACE_HIDDEN;}

		void	SetHide(BOOL hide) {if (hide) Hide(); else Show();}

	};







class TVFace {

	public:

		DWORD	t[3];  // indices into tVerts

		

		TVFace() {}

		TVFace(DWORD a, DWORD b, DWORD c) {t[0]=a; t[1]=b; t[2]=c;}

		void	setTVerts(DWORD *vrt){ memcpy(t, vrt, 3*sizeof(DWORD)); }

		void	setTVerts(int a, int b, int c)  { t[0]=a; t[1]=b; t[2]=c; }	

		DWORD	getTVert(int index)	{ return t[index]; }

		DWORD *	getAllTVerts(void)	{ return t; }

	};





		





// Flag definitions

#define MESH_EDGE_LIST 1



#define COMP_TRANSFORM	0x0001	// forces recalc of model->screen transform; else will attempt to use cache

#define COMP_IGN_RECT	0x0002	// forces all polys to be rendered; else only those intersecting the box will be

#define COMP_LIGHTING	0x0004	// forces re-lighting of all verts (as when a light moves); else only relight moved verts



#define COMP_ALL		0x00ff



// If this bit is set then the node being displayed by this mesh is selected.

// Certain display flags only activate when this bit is set.

#define COMP_OBJSELECTED	(1<<8)





typedef int (*INTRFUNC)();



DllExport void setMeshIntrFunc(INTRFUNC fn);





class MeshSubHitRec {

	private:		

		MeshSubHitRec *next;

	public:

		DWORD	dist;

		int		index;

		DWORD	flags;



		MeshSubHitRec(DWORD dist, int index, MeshSubHitRec *next) 

			{this->dist = dist; this->index = index; this->next = next;}

		MeshSubHitRec(DWORD dist, int index, DWORD flags, MeshSubHitRec *next) 

			{this->dist = dist; this->index = index; this->next = next;this->flags = flags;}



		MeshSubHitRec *Next() { return next; }		

	};



class SubObjHitList {

	private:

		MeshSubHitRec *first;

	public:

		SubObjHitList() { first = NULL; }

		~SubObjHitList() {

			MeshSubHitRec *ptr = first, *fptr;

			while (ptr) {

				fptr = ptr;

				ptr = ptr->Next();

				delete fptr;

				}

			first = NULL;

			}	



		MeshSubHitRec *First() { return first; }

		void AddHit( DWORD dist, int index ) {

			first = new MeshSubHitRec(dist,index,first);

			}

	};







// Flags for sub object hit test



// NOTE: these are the same bits used for object level.

#define SUBHIT_SELONLY		(1<<0)

#define SUBHIT_UNSELONLY	(1<<2)

#define SUBHIT_ABORTONHIT	(1<<3)

#define SUBHIT_SELSOLID		(1<<4)



#define SUBHIT_USEFACESEL	(1<<23)   // When this bit is set, the sel only and unsel only tests will use the faces selection when doing a vertex level hit test

#define SUBHIT_VERTS		(1<<24)

#define SUBHIT_FACES		(1<<25)

#define SUBHIT_EDGES		(1<<26)

#define SUBHIT_TYPEMASK		(SUBHIT_VERTS|SUBHIT_FACES|SUBHIT_EDGES)





// Display flags

#define DISP_VERTTICKS		(1<<0)

#define DISP_SELVERTS		(1<<10)

#define DISP_SELFACES		(1<<11)

#define DISP_SELEDGES		(1<<12)

#define DISP_SELPOLYS		(1<<13)



// Selection level bits.

#define MESH_OBJECT		(1<<0)

#define MESH_VERTEX		(1<<1)

#define MESH_FACE		(1<<2)

#define MESH_EDGE		(1<<3)



class MeshOpProgress;



class MeshRenderData {

	public:

	virtual void DeleteThis()=0;

	};



class Mesh {

	friend class Face;



	private:

#if MESH_MULTI_PROCESSING

		static int		refCount;

		static HANDLE	xfmThread;

		static HANDLE	xfmMutex;

		static HANDLE	xfmStartEvent;

		static HANDLE	xfmEndEvent;

		friend DWORD WINAPI xfmFunc(LPVOID ptr);

		static HANDLE	fNorThread;

		static HANDLE	fNorMutex;

		static HANDLE	fNorStartEvent;

		static HANDLE	fNorEndEvent;

		friend DWORD WINAPI fNorFunc(LPVOID ptr);

#endif

		// derived data-- can be regenerated

		RVertex 		*rVerts;		// <<< instance specific.

		GraphicsWindow 	*cacheGW;  		// identifies rVerts cache

		Point3	 		*faceNormal;	// object space--depends on geom+topo

		Box3			bdgBox;			// object space--depends on geom+topo

		int 			numVisEdges;	// depends on topo 

		int				edgeListHasAll;	// depends on topo

		VEdge 			*visEdge;		// depends on topo 	

 

 		// Vertex and face work arrays -- for snap code

		int			snapVCt;

		int			snapFCt;

		char		*snapV;

		char		*snapF;



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

		//

		long   		flags;		  	// work flags- 



		float 		norScale;	    // scale of normals -- couldn't this be done

		 							// automatically relative to bdgBox?



		// Rolf: these are instance specific and should be pulled out of here,

		// and just passed in from the Node.

		int			dspNormals;    // display surface normals--- put in flags?

		int			dspAllEdges;   // shows hidden edges  ---- put in flags?



		int 		renderFace(GraphicsWindow *gw, DWORD index, int *custVis=NULL);

		int			renderEdge(GraphicsWindow *gw, DWORD face, DWORD edge);

		void  		calcNormal(int i);

		void		checkRVertsAlloc(void);

		void		setCacheGW(GraphicsWindow *gw)	{ cacheGW = gw; }

		GraphicsWindow *getCacheGW(void)			{ return cacheGW; }



		void		buildFaceNormals();

		void		checkNormals(int illum);



		void 		freeVerts();

		void  		freeFaces();

		void		freeFaceNormals();  

		void  		freeRVerts();

		void  		freeTVerts();

		void 		freeT3DVerts();

		void  		freeTVFaces();

		void		freeSnapData();

		int			buildSnapData(GraphicsWindow *gw,int verts,int edges);



	public:

		// Topology

		int			numVerts;

		int	 		numFaces;

		Face *		faces;



		// Geometry

		Point3 *	verts;



		// Texture Coord assignment 

		int			numTVerts;

		UVVert *	tVerts;

		TVFace *	tvFace;  	 

		Point3 *	t3DVerts;	// Snap shot of regular vertices before a deformation



		// Material assignment

		MtlID		mtlIndex;     // object material

		MtlID	* 	faceMtlIndex; // material index per face. 



		// Selection

		BitArray	vertSel;  		// selected vertices

		BitArray	faceSel;  		// selected faces

		BitArray	edgeSel;		// selected edges, identified as 3*faceIndex + edgeIndex

		BitArray	vertHide;		// Hide flags for vertices



		// Display attribute flags

		DWORD		dispFlags;



		// Selection level

		DWORD		selLevel;



		// true if normals have been built for the current mesh

		int			normalsBuilt;



		MeshRenderData*	 renderData;  // used by the renderer



		DllExport Mesh();

		DllExport Mesh(const Mesh& fromMesh);

		DllExport ~Mesh();

		void 		Init();



		DllExport Mesh& operator=(const Mesh& fromMesh);

		

		DllExport BOOL 	setNumVerts(int ct, BOOL keep=FALSE);

		int				getNumVerts(void) const	{ return numVerts; }

		

		DllExport BOOL	setNumFaces(int ct, BOOL keep=FALSE);

		int				getNumFaces(void) const{ return numFaces; }

		

		DllExport BOOL	setNumTVerts(int ct, BOOL keep=FALSE);

		int				getNumTVerts(void) const { return numTVerts; }

		

		// These are parallel to faces and vertices (repectively)

		// These are called from setNumVets()/Faces() to maintain the same count.

		//

		// If they are NULL and keep = TRUE they stay NULL.

		// If they are NULL and keep = FALSE they are allocated (3D verts also init themselves from the main vert array)

		// If they are non-NULL and ct = 0 they are set to NULL (and freed)

		// NOTE that  T3DVerts are always initialized to either thier previous value (keep=1) or the vertex array

		// The old count is the length of the existing array (usually equal to numVerts but not if verts have just been resized also)

		DllExport BOOL 	setNumTVFaces(int ct, BOOL keep=FALSE, int oldCt=0);

		DllExport BOOL 	setNumT3DVerts(int ct, BOOL keep=FALSE, int oldCt=0);



		void		setVert(int i, const Point3 &xyz)	{ verts[i] = xyz; }

		void		setVert(int i, float x, float y, float z)	{ verts[i].x=x; verts[i].y=y; verts[i].z=z; }

		void		setTVert(int i, const UVVert &xyz)	{ tVerts[i] = xyz; }

		void		setTVert(int i, float x, float y, float z)	{ tVerts[i].x=x; tVerts[i].y=y; tVerts[i].z=z; }

		

		DllExport void		setNormal(int i, const Point3 &xyz); 

		DllExport Point3 &	getNormal(int i);



		void		setFaceNormal(int i, const Point3 &xyz) { faceNormal[i] =  xyz; }

		Point3 &	getFaceNormal(int i) { return faceNormal[i]; }



		Point3 &	getVert(int i)		{ return verts[i];  }

		Point3 *	getVertPtr(int i)	{ return verts+i; }

		UVVert &	getTVert(int i)		{ return tVerts[i];  }

		UVVert *	getTVertPtr(int i)	{ return tVerts+i; }

		RVertex &	getRVert(int i)		{ return rVerts[i]; }

		RVertex *	getRVertPtr(int i)	{ return rVerts+i; }

		

		void		setMtlIndex(MtlID	i)	{ mtlIndex = i; }

		MtlID		getMtlIndex(void) 		{ return mtlIndex; }



		// Face MtlIndex list methods;

		DllExport void		createFaceMtlIndexList();		

		void				freeFaceMtlIndexList();  

	    DllExport MtlID		getFaceMtlIndex(int i);  //	{ return faceMtlIndex? faceMtlIndex[i]: mtlIndex; }

		DllExport void		setFaceMtlIndex(int i, MtlID id); 	

		

		DllExport void		buildNormals();

		DllExport void 		buildRenderNormals(); // like buildNormals, but ignores mtlIndex



		DllExport void		render(GraphicsWindow *gw, Material *ma, RECT *rp, int compFlags, int numMat=1);

		DllExport BOOL		select(GraphicsWindow *gw, Material *ma, HitRegion *hr, int abortOnHit = FALSE, int numMat=1);

		DllExport void		snap(GraphicsWindow *gw, SnapInfo *snap, IPoint2 *p, Matrix3 &tm);

		DllExport BOOL 		SubObjectHitTest(GraphicsWindow *gw, Material *ma, HitRegion *hr,

								DWORD flags, SubObjHitList& hitList, int numMat=1 );



		void		displayNormals(int b, float sc)	{ dspNormals = b; if(sc != (float)0.0) norScale = sc; }

		void		displayAllEdges(int b)	{ dspAllEdges = b; }

		DllExport void		buildBoundingBox(void);

		DllExport Box3 		getBoundingBox(Matrix3 *tm=NULL); // RB: optional TM allows the box to be calculated in any space.

		                                              // NOTE: this will be slower becuase all the points must be transformed.

		

		DllExport void		EnableEdgeList(int e);

		DllExport void     	BuildVisEdgeList();

		DllExport void 		DrawVisEdgeList(GraphicsWindow *gw, DWORD flags);

		DllExport void		HitTestVisEdgeList(GraphicsWindow *gw, int abortOnHit ); // RB

		DllExport void		InvalidateEdgeList(); // RB

		DllExport void 		InvalidateGeomCache();

		DllExport void 		FreeAll(); //DS

				

		// functions for use in data flow evaluation

		DllExport void 		ShallowCopy(Mesh *amesh, unsigned long channels);

		DllExport void 		DeepCopy(Mesh *amesh, unsigned long channels);

		DllExport void		NewAndCopyChannels(unsigned long channels);

		DllExport void 		FreeChannels( unsigned long channels, int zeroOthers=1);



		// Display flags

		void		SetDispFlag(DWORD f) { dispFlags |= f; }

		DWORD		GetDispFlag(DWORD f) { return dispFlags & f; }

		void		ClearDispFlag(DWORD f) { dispFlags &= ~f; }



		// Selection access

		BitArray& 	VertSel() { return vertSel;  }	

		BitArray& 	FaceSel() { return faceSel;  }	



		// Constructs a vertex selection list based on the current selection level.

		DllExport BitArray 	VertexTempSel();



		DllExport IOResult Save(ISave* isave);

		DllExport IOResult Load(ILoad* iload);



		// RB: added so all objects can easily support the GeomObject method of the same name.

		DllExport int IntersectRay(Ray& ray, float& at, Point3& norm);



		// RB: I couldn't resist adding these <g>

		DllExport Mesh operator+(Mesh &mesh);  // Union

		DllExport Mesh operator-(Mesh &mesh);  // Difference

		DllExport Mesh operator*(Mesh &mesh);  // Intersection



		DllExport void WeldCollinear(BitArray &set);



		DllExport void Optimize(

			float normThresh, float edgeThresh, 

			float bias, DWORD flags, MeshOpProgress *prog=NULL);



		DllExport void ApplyUVWMap(int type,

			float utile, float vtile, float wtile,

			int uflip, int vflip, int wflip, int cap,

			const Matrix3 &tm);



		DllExport void FlipNormal(int i);

		DllExport void UnifyNormals(BOOL selOnly);

		DllExport void AutoSmooth(float angle,BOOL useSel);



		DllExport Edge *MakeEdgeList(int *edgeCount, int flagdbls=0);

		DllExport int DeleteFlaggedFaces(); // deletes all faces with FACE_WORK flag set



		// Returns TRUE if an equivalent face already exists.

		DllExport BOOL DoesFaceExist(DWORD v0, DWORD v1, DWORD v2);



		// Removes faces that have two or more equal indices.

		// Returns TRUE if any degenerate faces were found

		DllExport BOOL RemoveDegenerateFaces();



		// Removes faces that have indices that are out of range

		// Returns TRUE if any illegal faces were found

		DllExport BOOL RemoveIllegalFaces();



		DllExport float AngleBetweenFaces(DWORD f0, DWORD f1);



		// Compute the barycentric coords of a point in the plane of

		// a face relative to that face.

		DllExport Point3 BaryCoords(DWORD face, Point3 p);



		// Some edge operations

		DllExport void DivideEdge(DWORD edge);

		DllExport void TurnEdge(DWORD edge);		



		// used by the renderer

		void  SetRenderData(MeshRenderData *p) {renderData = p; } 

		MeshRenderData * GetRenderData() { return renderData; }

	};



// Mapping types passed to ApplyUVWMap()

#define MAP_PLANAR		0

#define MAP_CYLINDRICAL	1

#define MAP_SPHERICAL	2

#define MAP_BALL		3

#define MAP_BOX			4





// Optimize flags

#define OPTIMIZE_SAVEMATBOUNDRIES		(1<<0)

#define OPTIMIZE_SAVESMOOTHBOUNDRIES	(1<<1)

#define OPTIMIZE_AUTOEDGE				(1<<2)





void DllExport setUseVisEdge(int b);

int DllExport getUseVisEdge();



// a callback to update progress UI while doing a

// lengthy operation to a mesh

class MeshOpProgress {

	public:

		// called once with the total increments

		virtual void Init(int total)=0;



		// Called to update progress. % done = p/total

		virtual BOOL Progress(int p)=0;

	};



// Boolean operations for meshes:

#define MESHBOOL_UNION 				1

#define MESHBOOL_INTERSECTION  		2

#define MESHBOOL_DIFFERENCE 		3



//

// mesh = mesh1 op mesh2

// If tm1 or tm2 are non-NULL, the points of the corresponding

// mesh will be transformed by these tm before the bool op

// The mesh will be transformed back by either Inverse(tm1) or

// Inverse(tm2) depending whichInv (0=>tm1, 1=>tm2)

// unless whichInv is -1 in which case it will not be transformed

// back.

//

int DllExport CalcBoolOp(

	Mesh &mesh, Mesh &mesh1, Mesh &mesh2, int op,

	MeshOpProgress *prog = NULL,

	Matrix3 *tm1 = NULL,

	Matrix3 *tm2 = NULL,

	int whichInv = 0,

	int weld = TRUE);







DllExport void SetSubSelColor(Point3 *clr);

DllExport Point3 GetSubSelColor();



#endif // _MESH_H_