#ifndef __LEDSVERTEX_H__
#define __LEDSVERTEX_H__

#include "compgeomlib.h"

class CLEDSliteEdgeUse;
class CLEDSliteFace;
class CLEDSEdgeUse;
class CLEDSFace;
class CLEDSGeometry;

int ZVertexCompare(const void *arg1, const void *arg2);

//////////////////////////////////////////////////////////////////////////////
// CLEDSliteVertex Class
//

class CLEDSliteVertex : public CVertex 
{
//////////////////////////////////////////////////
// Enumerated Types
//

//////////////////////////////////////////////////
// Initialization
//
public:
  CLEDSliteVertex();
  virtual ~CLEDSliteVertex();
  virtual VOID Init(Point pt, CLEDSGeometry *pCG);
  virtual VOID Init(Point pt, CLEDSliteEdgeUse *pledsFirstEU, 
					CLEDSGeometry *pCG);
  virtual VOID Uninit();

//////////////////////////////////////////////////
// Geometric Computations
//
public:
  virtual VOID MergeVtx(CLEDSliteVertex *);
  virtual VOID CalculateBound(CBound *pCBound);
  virtual VOID CalculateBoundOffset(CBound *pCBound, FLOAT fDir, FLOAT fOffset);

  virtual VOID Null();
  virtual BOOL Homogenize();
  // Calculate Normal from 4 Vertexs CCW around this point
  virtual VOID CalculateNormal(const Point &pt0, const Point &pt1, 
		       const Point &pt2, const Point &pt3);

  // Should I have a Get function for this and store the list with the vertex,
  // or do we want to keep the vertex smaller?
  CListInt *MakeVtxEUCyclesList();
protected:
  CListInt *MakeVtxEUList(CLEDSliteEdgeUse *edge, CListInt *newContour);
  CLEDSliteEdgeUse *GetNextEdge(CLEDSliteEdgeUse *curEdge);
  VOID MatchSiblingEdgeUses(CLEDSliteVertex *,CLEDSliteVertex *);
  VOID RemoveZeroLengthEdges(CLEDSliteVertex *,CLEDSliteVertex *);
								 
//////////////////////////////////////////////////
// Rendering
//
public:

//////////////////////////////////////////////////
// Output Functions
//
public:
  virtual VOID Display() const;

//////////////////////////////////////////////////
// Accessor Functions
//
public:
  inline virtual Point GetPoint();
  inline virtual VOID SetPoint(const Point &pt);
  inline virtual Vector GetNormal();
  inline virtual VOID SetNormal(const Vector &v);
  inline virtual Point GetTexPoint();
  inline virtual VOID SetTexPoint(const Point &ptTex);

// Here I append ptr to the versions that return ptrs to LEDS, while
// in face and edgeuse I put LEDS after the get and set.  Make consistent!
  inline CLEDSliteEdgeUse *GetLEDSFirstEU() const;
  inline CLEDSGeometry *GetLEDSGeometry() const;
//  CLEDSEdgeUse *GetSafeLEDSFirstEU() const;
  inline VOID SetLEDSFirstEU(CLEDSliteEdgeUse *ledsEdgeUse);
  inline VOID SetExtra(VOID *);
  inline VOID *GetExtra();
//////////////////////////////////////////////////
// Class Variables
//
public:

//////////////////////////////////////////////////
// Member Variables
//
protected:
  UINT_32 m_uiID;
  CLEDSliteEdgeUse *m_pledsFirstEU;
  Point m_pt;
  Vector m_vNormal;
  CLEDSGeometry *m_pCLEDSGeometry;

  VOID *m_pExtra;
};

//////////////////////////////////////////////////////////////////////////////
// Inlined Functions
//

inline Point CLEDSliteVertex::GetPoint()
{
  return m_pt;
}

inline VOID CLEDSliteVertex::SetPoint(const Point &pt)
{
  m_pt = pt;
}

inline Vector CLEDSliteVertex::GetNormal() 
{
  Vector vNormal;
  return vNormal;
}

inline VOID CLEDSliteVertex::SetNormal(const Vector &/*v*/)
{
}

inline Point CLEDSliteVertex::GetTexPoint()
{
  // Well, it's a point...
  return m_pt;
}

inline VOID CLEDSliteVertex::SetTexPoint(const Point &/*ptTex*/)
{
}

inline CLEDSliteEdgeUse *CLEDSliteVertex::GetLEDSFirstEU() const
{
  return m_pledsFirstEU;
}

inline CLEDSGeometry *CLEDSliteVertex::GetLEDSGeometry() const
{
  return m_pCLEDSGeometry;
}


inline VOID CLEDSliteVertex::SetLEDSFirstEU(CLEDSliteEdgeUse *ledsFirstEU)
{
  m_pledsFirstEU = ledsFirstEU;
}

inline VOID CLEDSliteVertex::SetExtra(VOID *pExtra)
{
  m_pExtra = pExtra;
}

inline VOID *CLEDSliteVertex::GetExtra()
{
  return m_pExtra;
}
//////////////////////////////////////////////////////////////////////////////
// CLEDSVertex Class
//

class CLEDSVertex : public CLEDSliteVertex 
{
//////////////////////////////////////////////////
// Enumerated Types
//

//////////////////////////////////////////////////
// Initialization
//
public:
  CLEDSVertex();
  virtual ~CLEDSVertex();
  virtual VOID Init(LID lidLID, LID lidFirstEU, Point pt, CLEDSGeometry *pCG,
					UINT_32 uiOrigName = 0);
  virtual VOID Uninit();

//////////////////////////////////////////////////
// Geometric Computations
//
public:

//////////////////////////////////////////////////
// Rendering
//
public:

//////////////////////////////////////////////////
// Output Functions
//
public:
  virtual VOID Display() const;

//////////////////////////////////////////////////
// Accessor Functions
//
public:

  inline LID GetLID() const;
  inline VOID SetLID(const LID &lid);
  inline LID GetFirstEU() const;
  inline VOID SetFirstEU(const LID &lid);

  CLEDSEdgeUse *GetSafeLEDSFirstEU() const;

//////////////////////////////////////////////////
// Member Variables
//
protected:
  LID m_lidLID;
  LID m_lidFirstEU;
};


inline LID CLEDSVertex::GetLID() const
{
  return m_lidLID;
}

inline VOID CLEDSVertex::SetLID(const LID &lid)
{
  m_lidLID = lid;
}

inline LID CLEDSVertex::GetFirstEU() const
{
  return m_lidFirstEU;
}

inline VOID CLEDSVertex::SetFirstEU(const LID &lid)
{
 m_lidFirstEU = lid;
}


//////////////////////////////////////////////////////////////////////////////
// CLEDSliteVtxEdgeIter Class
//

class CLEDSliteVtxEdgeIter: public CGeometryIter
{
public:
  CLEDSliteVtxEdgeIter();
  virtual ~CLEDSliteVtxEdgeIter();
  virtual VOID Init(CLEDSliteVertex *pCLEDSVertex);

protected:
  virtual VOID Uninit();
  virtual BOOL Valid();

public:
  // Iteration Functions
  virtual CLEDSliteEdgeUse *PeekFirstVtxEdgeEU();
  virtual CLEDSliteEdgeUse *PeekNextVtxEdgeEU();

protected:
  CLEDSliteEdgeUse *m_pledsEdgeIter;
};


//////////////////////////////////////////////////////////////////////////////
// CLEDSVtxEdgeIter Class
//

class CLEDSVtxEdgeIter: public CLEDSliteVtxEdgeIter
{
public:
  CLEDSVtxEdgeIter();
  virtual ~CLEDSVtxEdgeIter();

protected:
  virtual VOID Uninit();

public:
  // Iteration Functions
  virtual CLEDSliteEdgeUse *PeekFirstVtxEdgeEU();
  virtual CLEDSliteEdgeUse *PeekNextVtxEdgeEU();

protected:
};



#endif // __LEDSVERTEX_H__