#ifndef _DDRAW_TRIEDGE_HPP_
#define _DDRAW_TRIEDGE_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif

class DirectTriEdge
{
public:
  DirectTriEdge(void);
	DirectTriEdge(int x0,int y0,int x1,int y1,int x2,int y2,int u0,int v0,int u1,int v1,int u2,int v2);
	DirectTriEdge(const DirectTriEdge &someDirectTriEdge);
	virtual ~DirectTriEdge();
	DirectTriEdge &operator=(const DirectTriEdge &someDirectTriEdge);
	BOOL operator==(const DirectTriEdge &someDirectTriEdge)const;
	int dxLeft(void)const;
	void dxLeft(int dxLeft);
	int dxRight(void)const;
	void dxRight(int dxRight);
	int duLeft(void)const;
	void duLeft(int duLeft);
	int duRight(void)const;
	void duRight(int duRight);
	int dvLeft(void)const;
	void dvLeft(int dvLeft);
	int dvRight(void)const;
	void dvRight(int dvRight);
	int xLeft(void)const;
	void xLeft(int xLeft);
	int xRight(void)const;
	void xRight(int xRight);
	int vLeft(void)const;
	void vLeft(int vLeft);
	int vRight(void)const;
	void vRight(int vRight);
	int uLeft(void)const;
	void uLeft(int uLeft);
	int uRight(void)const;
	void uRight(int uRight);
	int x0(void)const;
	void x0(int x0);
	int y0(void)const;
	void y0(int y0);
	int x1(void)const;
	void x1(int x1);
	int y1(void)const;
	void y1(int y1);
	int x2(void)const;
	void x2(int x2);
	int y2(void)const;
	void y2(int y2);
	int u0(void)const;
	void u0(int u0);
	int v0(void)const;
	void v0(int v0);
	int u1(void)const;
	void u1(int u1);
	int v1(void)const;
	void v1(int v1);
	int u2(void)const;
	void u2(int u2);
	int v2(void)const;
	void v2(int v2);
private:
  int mDXLeft;
	int mDXRight;
	int mDULeft;
	int mDURight;
	int mDVLeft;
	int mDVRight;
  int mxLeft;
	int mxRight;
	int mvLeft;
	int mvRight;
	int muLeft;
	int muRight;
  int mx0;
	int my0;
	int mx1;
	int my1;
	int mx2;
	int my2;
	int mu0;
	int mv0;
	int mu1;
	int mv1;
	int mu2;
	int mv2;
};

inline
DirectTriEdge::DirectTriEdge(void)
: mx0(0), my0(0), mx1(0), my1(0), mx2(0), my2(0), mu0(0), mv0(0), mu1(0), mv1(0), mu2(0), mv2(0),
  mxLeft(0), mxRight(0), mvLeft(0), mvRight(0), muLeft(0), muRight(0), mDXLeft(0), mDXRight(0),
	mDULeft(0), mDURight(0), mDVLeft(0), mDVRight(0)
{
}

inline
DirectTriEdge::DirectTriEdge(int x0,int y0,int x1,int y1,int x2,int y2,int u0,int v0,int u1,int v1,int u2,int v2)
: mx0(x0), my0(y0), mx1(x1), my1(y1), mx2(x2), my2(y2), mu0(u0), mv0(v0), mu1(u1), mv1(v1), mu2(u2), mv2(v2)
{
}

inline
DirectTriEdge::DirectTriEdge(const DirectTriEdge &someDirectTriEdge)
{
  *this=someDirectTriEdge;
}

inline
DirectTriEdge::~DirectTriEdge()
{
}

inline
DirectTriEdge &DirectTriEdge::operator=(const DirectTriEdge &someDirectTriEdge)
{
  x0(someDirectTriEdge.x0());
	y0(someDirectTriEdge.y0());
	x1(someDirectTriEdge.x1());
	y1(someDirectTriEdge.y1());
	x2(someDirectTriEdge.x2());
	y2(someDirectTriEdge.y2());
	u0(someDirectTriEdge.u0());
	v0(someDirectTriEdge.v0());
	u1(someDirectTriEdge.u1());
	v1(someDirectTriEdge.v1());
	u2(someDirectTriEdge.u2());
	v2(someDirectTriEdge.v2());
	xLeft(someDirectTriEdge.xLeft());
	xRight(someDirectTriEdge.xRight());
	uLeft(someDirectTriEdge.uLeft());
	uRight(someDirectTriEdge.uRight());
	vLeft(someDirectTriEdge.vLeft());
	vRight(someDirectTriEdge.vRight());
	dxLeft(someDirectTriEdge.dxLeft());
	dxRight(someDirectTriEdge.dxRight());
	duLeft(someDirectTriEdge.duLeft());
	duRight(someDirectTriEdge.duRight());
	dvLeft(someDirectTriEdge.dvLeft());
	dvRight(someDirectTriEdge.dvRight());
	return *this;
}

inline
BOOL DirectTriEdge::operator==(const DirectTriEdge &someDirectTriEdge)const
{
  return (x0()==someDirectTriEdge.x0()&&
	        y0()==someDirectTriEdge.y0()&&
	        x1()==someDirectTriEdge.x1()&&
	        y1()==someDirectTriEdge.y1()&&
	        x2()==someDirectTriEdge.x2()&&
	        y2()==someDirectTriEdge.y2()&&
	        u0()==someDirectTriEdge.u0()&&
	        v0()==someDirectTriEdge.v0()&&
	        u1()==someDirectTriEdge.u1()&&
	        v1()==someDirectTriEdge.v1()&&
	        u2()==someDirectTriEdge.u2()&&
	        v2()==someDirectTriEdge.v2()&&
					xLeft()==someDirectTriEdge.xLeft()&&
					xRight()==someDirectTriEdge.xRight()&&
					uLeft()==someDirectTriEdge.uLeft()&&
					uRight()==someDirectTriEdge.uRight()&&
					vLeft()==someDirectTriEdge.vLeft()&&
					vRight()==someDirectTriEdge.vRight()&&
					dxLeft()==someDirectTriEdge.dxLeft()&&
					dxRight()==someDirectTriEdge.dxRight()&&
					duLeft()==someDirectTriEdge.duLeft()&&
					duRight()==someDirectTriEdge.duRight()&&
					dvLeft()==someDirectTriEdge.dvLeft()&&
					dvRight()==someDirectTriEdge.dvRight());
}

inline
int DirectTriEdge::xLeft(void)const
{
  return mxLeft;
}

inline
void DirectTriEdge::xLeft(int xLeft)
{
  mxLeft=xLeft;
}

inline
int DirectTriEdge::xRight(void)const
{
  return mxRight;
}

inline
void DirectTriEdge::xRight(int xRight)
{
  mxRight=xRight;
}

inline
int DirectTriEdge::vLeft(void)const
{
  return mvLeft;
}

inline
void DirectTriEdge::vLeft(int vLeft)
{
  mvLeft=vLeft;
}

inline
int DirectTriEdge::vRight(void)const
{
  return mvRight;
}

inline
void DirectTriEdge::vRight(int vRight)
{
  mvRight=vRight;
}

inline
int DirectTriEdge::uLeft(void)const
{
  return muLeft;
}

inline
void DirectTriEdge::uLeft(int uLeft)
{
  muLeft=uLeft;
}

inline
int DirectTriEdge::uRight(void)const
{
  return muRight;
}

inline
void DirectTriEdge::uRight(int uRight)
{
  muRight=uRight;
}

inline
int DirectTriEdge::x0(void)const
{
  return mx0;
}

inline
void DirectTriEdge::x0(int x0)
{
  mx0=x0;
}

inline
int DirectTriEdge::y0(void)const
{
  return my0;
}

inline
void DirectTriEdge::y0(int y0)
{
  my0=y0;
}

inline
int DirectTriEdge::x1(void)const
{
  return mx1;
}

inline
void DirectTriEdge::x1(int x1)
{
  mx1=x1;
}

inline
int DirectTriEdge::y1(void)const
{
  return my1;
}

inline
void DirectTriEdge::y1(int y1)
{
  my1=y1;
}

inline
int DirectTriEdge::x2(void)const
{
  return mx2;
}

inline
void DirectTriEdge::x2(int x2)
{
  mx2=x2;
}

inline
int DirectTriEdge::y2(void)const
{
  return my2;
}

inline
void DirectTriEdge::y2(int y2)
{
  my2=y2;
}

inline
int DirectTriEdge::u0(void)const
{
  return mu0;
}

inline
void DirectTriEdge::u0(int u0)
{
  mu0=u0;
}

inline
int DirectTriEdge::v0(void)const
{
  return mv0;
}

inline
void DirectTriEdge::v0(int v0)
{
  mv0=v0;
}

inline
int DirectTriEdge::u1(void)const
{
  return mu1;
}

inline
void DirectTriEdge::u1(int u1)
{
  mu1=u1;
}

inline
int DirectTriEdge::v1(void)const
{
  return mv1;
}

inline
void DirectTriEdge::v1(int v1)
{
  mv1=v1;
}

inline
int DirectTriEdge::u2(void)const
{
  return mu2;
}

inline
void DirectTriEdge::u2(int u2)
{
  mu2=u2;
}

inline
int DirectTriEdge::v2(void)const
{
  return mv2;
}

inline
void DirectTriEdge::v2(int v2)
{
  mv2=v2;
}

inline
int DirectTriEdge::dxLeft(void)const
{
  return mDXLeft;
}

inline
void DirectTriEdge::dxLeft(int dxLeft)
{
  mDXLeft=dxLeft;
}

inline
int DirectTriEdge::dxRight(void)const
{
  return mDXRight;
}

inline
void DirectTriEdge::dxRight(int dxRight)
{
  mDXRight=dxRight;
}

inline
int DirectTriEdge::duLeft(void)const
{
  return mDULeft;
}

inline
void DirectTriEdge::duLeft(int duLeft)
{
  mDULeft=duLeft;
}

inline
int DirectTriEdge::duRight(void)const
{
  return mDURight;
}

inline
void DirectTriEdge::duRight(int duRight)
{
  mDURight=duRight;
}

inline
int DirectTriEdge::dvLeft(void)const
{
  return mDVLeft;
}

inline
void DirectTriEdge::dvLeft(int dvLeft)
{
  mDVLeft=dvLeft;
}

inline
int DirectTriEdge::dvRight(void)const
{
  return mDVRight;
}

inline
void DirectTriEdge::dvRight(int dvRight)
{
  mDVRight=dvRight;
}
#endif