source: GTP/trunk/App/Demos/Vis/CHC_revisited/Camera.cpp @ 2778

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


namespace CHCDemoEngine 
{

using namespace std;


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

        mPitch = mYaw = 0;
        Precompute();
}


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));

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

        mPitch = mYaw = 0;
        Precompute();
}


void Camera::Precompute() 
{
        Vector3 direction = Vector3(0, 1, 0);

        Vector3 side = CrossProd(Vector3(1, 0, 0), direction);
        
        Vector3 up = -Normalize(CrossProd(side, direction));
        Vector3 right = -Normalize(CrossProd(direction, up));

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



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


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


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;
        //matProjectionView = matProjectionView * matViewing;
        
        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()
{
#if 1
        //Matrix4x4 viewOrientation(mRight, mDirection, mUp);
        //Matrix4x4 viewOrientation(mRight, mUp, mDirection);
        Matrix4x4 tview = mViewOrientation;

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

        Debug << "vieworient:\n" << mViewOrientation << " pos " << pos << " position " << mPosition << endl;

        Matrix4x4 viewOrientation = mViewOrientation;

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

        glLoadIdentity();
        glMultMatrixf((float *)viewOrientation.x);
        //glMultMatrixf((float *)tm.x);
        Debug << "matrix:\n" << viewOrientation << endl;
#else
        glLoadIdentity();

        gluLookAt(mPosition.x, mPosition.y, mPosition.z,
                  mPosition.x + mDirection.x, mPosition.y + mDirection.y, mPosition.z + mDirection.z, 
                          mUp.x, mUp.y, mUp.z);
#endif
        //std::cout << "dir: " << mDirection << " pos: " << mPosition << " up: " << mUp << std::endl;
}



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

        const float h_near = 2.0f * tan(mFovy / 2) * z_near;
        const float w_near = h_near * GetAspect();
        const float h_far = 2.0f * tan(mFovy / 2) * z_far;
        const float w_far = h_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();
        /*
        Matrix4x4 viewOrientation(mRight, mUp, mDirection);
        Matrix4x4 rot = RotationYMatrix(angle);

        viewOrientation = viewOrientation * rot;

        mDirection = Vector3(viewOrientation.x[2][0], viewOrientation.x[2][1], viewOrientation.x[2][2]);
        mRight =     Vector3(viewOrientation.x[0][0], viewOrientation.x[0][1], viewOrientation.x[0][2]);
        mUp =        Vector3(viewOrientation.x[1][0], viewOrientation.x[1][1], viewOrientation.x[1][2]);*/
}


void Camera::Pitch(float angle)
{
        mPitch += angle;
        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]);
                
}


}