#ifndef _ENGINE_PUREVIEWSYSTEM_HPP_
#define _ENGINE_PUREVIEWSYSTEM_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_MATH_HPP_
#include <common/math.hpp>
#endif
#ifndef _ENGINE_POINT3D_HPP_
#include <engine/point3d.hpp>
#endif


#include <stdio.h>
#include <common/string.hpp>

class PureViewSystem;
class Polygon3D;
class Vector3D;
class Vector2D;

extern "C"
{
	void initView(PureViewSystem FAR *lpViewSystem);
	void mapCoordinates(Point3D *lpPoint3D,Point *lpPoint,DWORD useCartesianSystem);
	void mapVectorCoordinates(Point3D *lpPoint3D,Point *lpPoint,DWORD useCartesianSystem);
	void mapPolygonCoordinates(Polygon3D *pPolygon3D);
}

// do not make changes to this class that will alter its size

class PureViewSystem
{
public:
	enum MapMode{ScreenSystem=0,CartesianSystem=1};
	PureViewSystem(void);
	PureViewSystem(const PureViewSystem &somePureViewSystem);
	PureViewSystem(float cameraTwistDegrees,int viewPlaneDistance,Point3D cameraPoint,Point3D focusPoint);
	~PureViewSystem();                 
	PureViewSystem &operator=(const PureViewSystem &somePureViewSystem);
	WORD operator==(const PureViewSystem &somePureViewSystem)const;
	float cameraTwistDegrees(void)const; // rotation about axis established by camera and focus points
	void cameraTwistDegrees(float cameraTwistDegrees);
	DWORD viewPlaneDistance(void);       // distancle from view point to view plane
	void viewPlaneDistance(DWORD viewPlaneDistance);
	Point3D cameraPoint(void)const;      // view reference point (origin of coordinate system)
	void cameraPoint(Point3D point3D);
	Point3D focusPoint(void)const;       // direction is which camera is pointing   
	void focusPoint(Point3D point3D);
protected:
	void translatePoint(const Vector3D &vector3D,Vector2D &vector2D,MapMode mapMode=CartesianSystem);
	void translatePoint(Polygon3D &polygon,MapMode mapMode=CartesianSystem);
	void translatePoint(Point &dimensionPoint,Point &screenPoint,const Point3D &initialPoint,MapMode mapMode=CartesianSystem);
  void mapCoordinates(Point3D &firstPoint3D,Point &firstPoint,bool useCartesian=true);
	void viewPortWidth(WORD viewPortWidth);
	void viewPortHeight(WORD viewPortHeight);
private:
	enum {Precision=16384};
	enum {DefaultCameraTwistDegrees=120};
	enum {DefaultViewPlaneDistance=50};
	enum {DefaultFocusx=0,DefaultFocusy=0,DefaultFocusz=-1};
  enum {DefaultCamerax=75,DefaultCameray=75,DefaultCameraz=75};
	LONG mCameraTwistRadians;
	LONG mCosCameraTwistRadians;
	LONG mSinCameraTwistRadians;
	LONG mCosCameraTwistRadiansSinCameraTwistRadians;
	DWORD mViewPlaneDistance;
	WORD mViewPortWidth;
  WORD mViewPortHeight;
	Point3D mCameraPoint;
	Point3D mFocusPoint;
};

inline
PureViewSystem::PureViewSystem(void)
: mViewPlaneDistance(DefaultViewPlaneDistance), mViewPortWidth(0), mViewPortHeight(0),
	mCameraPoint(Point3D(DefaultCamerax,DefaultCameray,DefaultCameraz)),
  mFocusPoint(Point3D(DefaultFocusx,DefaultFocusy,DefaultFocusz))
{
  cameraTwistDegrees(DefaultCameraTwistDegrees);
}

inline
PureViewSystem::PureViewSystem(float cameraTwistDegrees,int viewPlaneDistance,Point3D cameraPoint,Point3D focusPoint)
{
	PureViewSystem::cameraTwistDegrees(cameraTwistDegrees);
	PureViewSystem::viewPlaneDistance(viewPlaneDistance);
	PureViewSystem::cameraPoint(cameraPoint);
  PureViewSystem::focusPoint(focusPoint);
}

inline
PureViewSystem::~PureViewSystem()
{
}

inline
PureViewSystem::PureViewSystem(const PureViewSystem &somePureViewSystem)
{
  *this=somePureViewSystem;
}

inline
PureViewSystem &PureViewSystem::operator=(const PureViewSystem &somePureViewSystem)
{
	mCameraTwistRadians=somePureViewSystem.mCameraTwistRadians;
	mCosCameraTwistRadians=somePureViewSystem.mCosCameraTwistRadians;
	mSinCameraTwistRadians=somePureViewSystem.mSinCameraTwistRadians;
	mCosCameraTwistRadiansSinCameraTwistRadians=somePureViewSystem.mCosCameraTwistRadiansSinCameraTwistRadians;
	mViewPlaneDistance=somePureViewSystem.mViewPlaneDistance;
	mViewPortWidth=somePureViewSystem.mViewPortWidth;
	mViewPortHeight=somePureViewSystem.mViewPortHeight;
	mCameraPoint=somePureViewSystem.mCameraPoint;
	mFocusPoint=somePureViewSystem.mFocusPoint;
	return *this;
}

inline
WORD PureViewSystem::operator==(const PureViewSystem &somePureViewSystem)const
{
	return (mCameraTwistRadians==somePureViewSystem.mCameraTwistRadians&&
					mViewPlaneDistance==somePureViewSystem.mViewPlaneDistance&&
					mCameraPoint==somePureViewSystem.mCameraPoint&&
					mFocusPoint==somePureViewSystem.mFocusPoint);
}

inline
float PureViewSystem::cameraTwistDegrees(void)const
{
	float cameraTwistDegrees((float)mCameraTwistRadians/(float)Precision);
  return Math::degrees(cameraTwistDegrees);
}

inline
DWORD PureViewSystem::viewPlaneDistance(void)
{
	return mViewPlaneDistance;
}

inline
void PureViewSystem::viewPlaneDistance(DWORD viewPlaneDistance)
{
  mViewPlaneDistance=viewPlaneDistance;
}

inline
Point3D PureViewSystem::cameraPoint(void)const
{
	return mCameraPoint;
}

inline
void PureViewSystem::cameraPoint(Point3D point3D)
{
  mCameraPoint=point3D;
}

inline
Point3D PureViewSystem::focusPoint(void)const
{
	return mFocusPoint;
}

inline
void PureViewSystem::focusPoint(Point3D point3D)
{
  mFocusPoint=point3D;
}

inline
void PureViewSystem::viewPortWidth(WORD viewPortWidth)
{
  mViewPortWidth=viewPortWidth;
}

inline
void PureViewSystem::viewPortHeight(WORD viewPortHeight)
{
  mViewPortHeight=viewPortHeight;
}

inline
void PureViewSystem::mapCoordinates(Point3D &firstPoint3D,Point &firstPoint,bool useCartesian)
{
	Point3D point3D(firstPoint3D);
	Point point(firstPoint);

	initView((PureViewSystem*)this);
	::mapCoordinates(&point3D,&point,useCartesian?CartesianSystem:ScreenSystem);
	firstPoint3D=point3D;
	firstPoint=point;
}
#endif