Initial

engine/PUREVSYS.BAK

@@ -0,0 +1,189 @@
+#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
+
+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};
+	enum {Precision=16384};
+	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);       // distance 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);
+	void viewPortWidth(WORD viewPortWidth);
+	void viewPortHeight(WORD viewPortHeight);
+private:
+	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)
+{
+	Point3D point3D(firstPoint3D);
+	Point point(firstPoint);
+
+	initView((PureViewSystem*)this);
+	::mapCoordinates(&point3D,&point,TRUE);
+	firstPoint3D=point3D;
+	firstPoint=point;
+}
+#endif