292 lines
7.5 KiB
C++
292 lines
7.5 KiB
C++
// K3DCamera.h: interface for the K3DCamera class.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
#if !defined(AFX_K3DCAMERA_H__87E8A41E_F986_4EB7_91BC_81EC2F3D414F__INCLUDED_)
|
|
#define AFX_K3DCAMERA_H__87E8A41E_F986_4EB7_91BC_81EC2F3D414F__INCLUDED_
|
|
|
|
#if _MSC_VER > 1000
|
|
#pragma once
|
|
#endif // _MSC_VER > 1000
|
|
#include "K3DTypes.h"
|
|
//#include "K3DFrustum.h"
|
|
class KViewportObject;
|
|
//class K3DRenderDeviceDX;
|
|
|
|
/**
|
|
K3DCamera class Description
|
|
- This class sets view matrix and projection matrix to viewport when render is called.
|
|
- Support pan (like side step), turn, elavation (vertical turn), zoom.
|
|
- Need to call the Initialize Function before using this class.
|
|
*/
|
|
class K3DCamera
|
|
{
|
|
public:
|
|
K3DCamera();
|
|
~K3DCamera();
|
|
|
|
/// Reset Camera Status.
|
|
/**
|
|
fov : 24 degree, near : 100, far : 50000 \n
|
|
distance from target : 1500 , elvation : 1.57 / 2.0 (radian) - 45 degree \n
|
|
Cam Pos x,y,z = {0, 1500 * sin45 degree, 1500 * cos45 degree} \n
|
|
Target Pos = {0,0,0} Up Vector = { 0, 0 , 1} \n
|
|
*/
|
|
void Reset();
|
|
|
|
/// Initialize Camera
|
|
void Initialize( float fov)
|
|
{
|
|
m_fFOV = fov;
|
|
}
|
|
|
|
void SetFOV( float fov )
|
|
{
|
|
m_fFOV = fov;
|
|
}
|
|
|
|
float GetFOV() const
|
|
{
|
|
return m_fFOV;
|
|
}
|
|
|
|
void SetCoordinateToRightHand() { m_bIsRightHandCoordinate = true; }
|
|
void SetCoordinateToLeftHand() { m_bIsRightHandCoordinate = false; }
|
|
bool IsCoordinateRightHand() const { return m_bIsRightHandCoordinate; }
|
|
bool IsCoordinateLeftHand() const { return !m_bIsRightHandCoordinate; }
|
|
|
|
void SetCameraPerspectiveMode() { m_bIsPerspective = true; }
|
|
void SetCameraOrthogonalMode() { m_bIsPerspective = false; }
|
|
bool IsCameraPerspectiveMode() const { return m_bIsPerspective; }
|
|
bool IsCameraOrthogonalMode() const { return !m_bIsPerspective; }
|
|
|
|
K3DVector GetCamPos() const
|
|
{
|
|
return K3DVector( m_fXPos, m_fYPos, m_fZPos );
|
|
}
|
|
void GetCamPos(float &x,float &y,float &z ) const
|
|
{
|
|
x = m_fXPos; y = m_fYPos; z = m_fZPos;
|
|
}
|
|
|
|
K3DVector GetCamOrgPos() const
|
|
{
|
|
return K3DVector( m_fOrgXPos, m_fOrgYPos, m_fOrgZPos );
|
|
}
|
|
|
|
void GetCamOrgPos(float &x,float &y,float &z ) const
|
|
{
|
|
x = m_fOrgXPos; y = m_fOrgYPos; z = m_fOrgZPos;
|
|
}
|
|
|
|
K3DVector GetTargetPos() const
|
|
{
|
|
return K3DVector( m_fTXPos, m_fTYPos, m_fTZPos );
|
|
}
|
|
|
|
void GetTargetPos(float &x,float &y,float &z ) const
|
|
{
|
|
x= m_fTXPos; y = m_fTYPos; z = m_fTZPos;
|
|
}
|
|
|
|
void SetCamPos( float x, float y, float z )
|
|
{
|
|
m_fXPos = x; m_fYPos = y; m_fZPos = z;
|
|
m_fOrgXPos = m_fXPos; m_fOrgYPos = m_fYPos; m_fOrgZPos = m_fZPos;
|
|
}
|
|
|
|
void SetCurCamPos( float x, float y, float z )
|
|
{
|
|
m_fXPos = x; m_fYPos = y; m_fZPos = z;
|
|
// m_fOrgXPos = m_fXPos; m_fOrgYPos = m_fYPos; m_fOrgZPos = m_fZPos;
|
|
}
|
|
|
|
void SetOrgCamPos( float x, float y, float z )
|
|
{
|
|
m_fOrgXPos = x; m_fOrgYPos = y; m_fOrgZPos = z;
|
|
}
|
|
|
|
void SetCurCamPos(float fRatio)
|
|
{
|
|
if(fRatio <= 0.0f || fRatio > 1.0f) return;
|
|
|
|
K3DVector vres;
|
|
K3DVector v1(m_fTXPos, m_fTYPos, m_fTZPos);
|
|
K3DVector v2(m_fOrgXPos, m_fOrgYPos, m_fOrgZPos);
|
|
|
|
vres = v1 + (v2 - v1) * fRatio;
|
|
|
|
m_fXPos = vres.x;
|
|
m_fYPos = vres.y;
|
|
m_fZPos = vres.z;
|
|
}
|
|
|
|
void SetTargetPos( float x, float y, float z )
|
|
{
|
|
m_fTXPos = x; m_fTYPos = y; m_fTZPos = z;
|
|
}
|
|
|
|
/// Set Panning(like side move)
|
|
/**
|
|
Camera Pos = Vc, Target Pos = Vt, Argument Pos = Va \n
|
|
Diff Vector Vd = Va - Vt, and new Vc = Vc + Vd \n
|
|
Setting Vt = Va \n
|
|
*/
|
|
void SetPan( float x, float y, float z )
|
|
{
|
|
float dx = x - m_fTXPos;
|
|
float dy = y - m_fTYPos;
|
|
float dz = z - m_fTZPos;
|
|
m_fXPos += dx;
|
|
m_fYPos += dy;
|
|
m_fZPos += dz;
|
|
m_fOrgXPos += dx;
|
|
m_fOrgYPos += dy;
|
|
m_fOrgZPos += dz;
|
|
m_fTXPos = x;
|
|
m_fTYPos = y;
|
|
m_fTZPos = z;
|
|
}
|
|
|
|
/// Get View matrix from Cam Pos, Target Pos
|
|
/**
|
|
@return K3DMatrix Pointer which denote View Matrix.
|
|
*/
|
|
K3DMatrix *GetViewMatrix();
|
|
//K3DMatrix *GetProjMatrix();
|
|
|
|
void Point(float fXPos, float fYPos, float fZPos, float fTXPos, float fTYPos, float fTZPos);
|
|
/// Set Elavation (Vetical Turn)
|
|
/**
|
|
@param fAngle Radian Unit.
|
|
This function will cause a problem if the value of fAngle becomes larger than \n
|
|
(1.57) 90 degrees.\n
|
|
(Because UPVector and SideVector going to be same direction.) \n
|
|
*/
|
|
void Elevation(float fAngle);
|
|
/// Set Turn (Horizontal Turn)
|
|
/**
|
|
@param fAngle Radian Unit.
|
|
*/
|
|
void Turn(float fAngle);
|
|
/// Pannig Camera
|
|
/**
|
|
@param dx,dy,dz : How you can get these panning arguments?
|
|
Some preprocessing is needed. See the below! \n \n
|
|
K3DVector vtView = m_pCamera->GetViewVector(); \n
|
|
K3DVector vtUp = m_pCamera->GetUpVector(); \n
|
|
K3DVector vtRes = CrossProduct(vtView, vtUp); // Get Side Vector. \n
|
|
Normalize(vtRes); \n
|
|
vtUp = CrossProduct(vtRes, vtView); // Get appropriate UpVector. \n
|
|
Normalize(vtUp); \n
|
|
If you need horizontal pannig, use vtRes. \n
|
|
else if you need vertical panning, use vtUp. \n
|
|
*/
|
|
void Pan(float dx, float dy, float dz);
|
|
/// 2010.11.11 카메라 방향에 맞게 - prodongi
|
|
void PanWithCamDir(float dx, float dy, float dz);
|
|
|
|
/// Zoom Camera
|
|
/**
|
|
@param dist : The camera's distance will be descreased by dist value. And cam pos changed too.
|
|
*/
|
|
void Zoom(float dist);
|
|
|
|
/// Get Camera's view vector ( Target Pos - Cam Pos)
|
|
/**
|
|
@return Normalized Vt - Vc.
|
|
*/
|
|
K3DVector GetViewVector() const
|
|
{
|
|
K3DVector vtView = K3DVector(m_fTXPos - m_fXPos, m_fTYPos - m_fYPos, m_fTZPos - m_fZPos);
|
|
Normalize(vtView);
|
|
return vtView;
|
|
}
|
|
|
|
K3DVector GetOrgViewVector() const
|
|
{
|
|
K3DVector vtView = K3DVector(m_fTXPos - m_fOrgXPos, m_fTYPos - m_fOrgYPos, m_fTZPos - m_fOrgZPos);
|
|
Normalize(vtView);
|
|
return vtView;
|
|
}
|
|
|
|
K3DVector GetUpVector() const
|
|
{
|
|
return m_dxvtUp;
|
|
}
|
|
|
|
void SetUpVector(float x, float y, float z)
|
|
{
|
|
m_dxvtUp = K3DVector(x,y,z);
|
|
}
|
|
|
|
/// Get Distance between Cam Pos and Target Pos.
|
|
/**
|
|
@return ||Vt - Vc|| + 0.5f
|
|
*/
|
|
float GetDistance()
|
|
{
|
|
m_fDistance = sqrtf( powf(m_fXPos - m_fTXPos, 2) +
|
|
powf(m_fYPos - m_fTYPos, 2) +
|
|
powf(m_fZPos - m_fTZPos,2) ) + .5f;
|
|
|
|
return m_fDistance;
|
|
}
|
|
/// Render this camera.
|
|
/**
|
|
* It will set view Matrix and projection Matrix to viewport.
|
|
*/
|
|
//void Render( KViewportObject *viewport, bool bOffSet = false );
|
|
|
|
/// Get two vertex from near clip point and far clip point.
|
|
/*!
|
|
Compute line which is linked from near clip to far clip.
|
|
@param srcx, srcy (in) : Screen coordinate.
|
|
@param vNear (out) : 3D point in near clipping plane.
|
|
@param vFar (out) : 3D point in far clipping plane.
|
|
*/
|
|
//void GetLineFromScreen( KViewportObject* pViewport, int scrx, int scry, K3DVector *vNear, K3DVector *vFar ) const;
|
|
//void GetScreenPosition( KViewportObject* pViewport, const K3DVector & vWorldPos, int *pPosX, int *pPosY);
|
|
//void GetFrustumCube( KViewportObject* pViewport, const KViewportStruct& rViewPort, int nMarginX, int nMarginY, K3DVertex* pFrustumCube ) const;
|
|
|
|
//
|
|
void SetMinDistance( float fMinDistance ) { m_fMinDistance = fMinDistance; m_bUseMinDistance=true; }
|
|
|
|
//K3DVector* GetFrustum(KViewportObject* pViewport);
|
|
|
|
void FileTextOut( FILE* pF );
|
|
void FileTextIn( char *pBuf );
|
|
|
|
private:
|
|
//void _MakeFrustum(KViewportObject* pViewport);
|
|
|
|
//K3DFrustum m_Frustum;
|
|
|
|
bool m_bIsRightHandCoordinate;
|
|
bool m_bIsPerspective;
|
|
|
|
float m_fFOV;
|
|
float m_fXPos, m_fYPos, m_fZPos;
|
|
float m_fOrgXPos, m_fOrgYPos, m_fOrgZPos;
|
|
float m_fTXPos, m_fTYPos, m_fTZPos;
|
|
float m_fZoomDelta;
|
|
|
|
K3DVector m_dxvtUp;
|
|
|
|
float m_fElavation;
|
|
float m_fTurn;
|
|
float m_fDistance;
|
|
|
|
bool m_bUseMinDistance;
|
|
float m_fMinDistance;
|
|
|
|
K3DMatrix m_MatView;
|
|
// K3DMatrix m_matProjection;
|
|
|
|
K3DMatrix m_OffSetMatView;
|
|
|
|
K3DVALUE m_fValue; ///< 제한 각
|
|
};
|
|
|
|
#endif // !defined(AFX_K3DCAMERA_H__87E8A41E_F986_4EB7_91BC_81EC2F3D414F__INCLUDED_)
|