source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Camera.cpp @ 2864

#include "common.h"
#include "Camera.h"
#include "glInterface.h"


namespace CHCDemoEngine 
{

using namespace std;


Camera::Camera() 
{
        mWidth = 100;
        mHeight = 100;
        mFovy = 60.0f * M_PI / 180.0f;
        mIsOrtho = false;
        
        SetPosition(Vector3(0, 0, 0));

        mPitch = mYaw = 0;
        Precompute(Vector3(0, 1, 0));
}


Camera::Camera(int width, int height, float fieldOfView) 
{
        mWidth = width;
        mHeight = height;
        
        mFovy = fieldOfView * M_PI / 180.0f;

        mIsOrtho = false;

        SetPosition(Vector3(0, 0, 0));

        mPitch = mYaw = 0;
        Precompute(Vector3(0, 1, 0));
}


void Camera::Precompute(const Vector3 &direction) 
{
        Vector3 up = Vector3(0, 0, 1);
        Vector3 right = Normalize(CrossProd(up, direction));
        up = Normalize(CrossProd(direction, right));

        mBaseOrientation = Matrix4x4(right, up, direction);
        mViewOrientation = mBaseOrientation;
}



void Camera::SetPosition(const Vector3 &pos) 
{
        mPosition = pos;
}


void Camera::SetNear(float nearDist) 
{
        mNear = nearDist;
}


void Camera::SetFar(float farDist) 
{ 
        mFar = farDist; 
}


void Camera::GetProjectionMatrix(Matrix4x4 &mat)
{
        glGetFloatv(GL_PROJECTION_MATRIX, (float *)mat.x);
}


void Camera::GetModelViewMatrix(Matrix4x4 &mat)
{
        glGetFloatv(GL_MODELVIEW_MATRIX, (float *)mat.x);
}


void Camera::CalcFrustum(Frustum &frustum)
{
        // we grab the plane equations of the six clipplanes of the viewfrustum
        Matrix4x4 matViewing, matProjectionView;

        GetModelViewMatrix(matViewing);
        GetProjectionMatrix(matProjectionView);

        matProjectionView = matViewing * matProjectionView;
                
        float planes[6][4];


        //////////
        //-- extract the plane equations

        for (int i = 0; i < 4; ++ i)
        {
                planes[0][i] = matProjectionView.x[i][3] - matProjectionView.x[i][0]; // right plane
                planes[1][i] = matProjectionView.x[i][3] + matProjectionView.x[i][0]; // left plane
                planes[2][i] = matProjectionView.x[i][3] + matProjectionView.x[i][1]; // bottom plane
                planes[3][i] = matProjectionView.x[i][3] - matProjectionView.x[i][1]; // top plane
                planes[4][i] = matProjectionView.x[i][3] - matProjectionView.x[i][2]; // far plane
                planes[5][i] = matProjectionView.x[i][3] + matProjectionView.x[i][2]; // near plane
        }


        ////////////
        //-- normalize the coefficients

        for (int i = 0; i < 6; ++ i)
        {
                // the clipping planes look outward the frustum,
                // so distances > 0 mean that a point is outside
                float fInvLength = -1.0f / 
                        sqrt(planes[i][0] * planes[i][0] +      
                             planes[i][1] * planes[i][1] +      
                                 planes[i][2] * planes[i][2]);

                planes[i][0] *= fInvLength;
                planes[i][1] *= fInvLength;
                planes[i][2] *= fInvLength;
                planes[i][3] *= fInvLength;

                frustum.mClipPlanes[i].mNormal = Vector3(planes[i][0], planes[i][1], planes[i][2]);
                frustum.mClipPlanes[i].mD = planes[i][3];
        }
}


void Camera::Frustum::CalcNPVertexIndices(int *indices)
{
        for (int i = 0; i < 6; ++ i)
        {
                // n-vertex
                indices[i * 2 + 0] = AxisAlignedBox3::GetIndexNearestVertex(mClipPlanes[i].mNormal);
                // p-vertex
                indices[i * 2 + 1] = AxisAlignedBox3::GetIndexFarthestVertex(mClipPlanes[i].mNormal);   
        }
}


void Camera::SetupCameraView()
{
        Matrix4x4 tview = mViewOrientation;

        Vector3 pos = -mPosition;
        pos = tview * pos;

        Matrix4x4 viewOrientation = mViewOrientation;

        viewOrientation.x[3][0] = pos.x;
        viewOrientation.x[3][1] = pos.y;
        viewOrientation.x[3][2] = pos.z;

        glLoadMatrixf((float *)viewOrientation.x);
}



void Camera::ComputePoints(Vector3 &ftl, Vector3 &ftr, Vector3 &fbl, Vector3 &fbr,
                                                   Vector3 &ntl, Vector3 &ntr, Vector3 &nbl, Vector3 &nbr)
{
        float z_near = mNear;
        float z_far = mFar;

        const float w_near = 2.0f * tan(mFovy / 2) * z_near;
        const float h_near = w_near / GetAspect();
        const float w_far = 2.0f * tan(mFovy / 2) * z_far;
        const float h_far = w_far / GetAspect();

        const Vector3 view = GetDirection();
        const Vector3 fc = mPosition + view * z_far; 
        
        const Vector3 up = GetUpVector();
        const Vector3 right = GetRightVector();

        Vector3 t1, t2;

        t1 = h_far * 0.5f * up;
        t2 = w_far * 0.5f * right;

        ftl = fc + t1 - t2;
        ftr = fc + t1 + t2;
        fbl = fc - t1 - t2;
        fbr = fc - t1 + t2;

        const Vector3 nc = mPosition + view * z_near;
        
        t1 = h_near * 0.5f * up;
        t2 = w_near * 0.5f * right;

        ntl = nc + t1 - t2;
        ntr = nc + t1 + t2;
        nbl = nc - t1 - t2;
        nbr = nc - t1 + t2;
}


void Camera::SetOrtho(bool ortho)
{
        mIsOrtho = true;
}


void Camera::Yaw(float angle)
{
        mYaw += angle;
        CalculateFromPitchAndYaw();
}


void Camera::Pitch(float angle)
{
        mPitch += angle;
        CalculateFromPitchAndYaw();
}


void Camera::SetDirection(const Vector3 &dir)
{
        Normalize(dir);

        mPitch = atan2(dir.x, dir.z);
        mYaw = atan2(dir.y, sqrt((dir.x * dir.x) + (dir.z * dir.z)));

        CalculateFromPitchAndYaw();
}


void Camera::CalculateFromPitchAndYaw()
{
        mViewOrientation = mBaseOrientation;

        Matrix4x4 roty = RotationYMatrix(mPitch);
        Matrix4x4 rotx = RotationXMatrix(mYaw);

        mViewOrientation *= roty;
        mViewOrientation *= rotx;
}


Vector3 Camera::GetDirection() const
{ 
        return -Vector3(mViewOrientation.x[0][2], mViewOrientation.x[1][2], mViewOrientation.x[2][2]);
}


Vector3 Camera::GetUpVector() const 
{ 
        return Vector3(mViewOrientation.x[0][1], mViewOrientation.x[1][1], mViewOrientation.x[2][1]);
}


Vector3 Camera::GetRightVector() const 
{ 
        return Vector3(mViewOrientation.x[0][0], mViewOrientation.x[1][0], mViewOrientation.x[2][0]);
                
}


}