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

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


namespace CHCDemoEngine 
{


Camera::Camera() 
{
        mWidth = 100;
        mHeight = 100;
        mFovy = 90.0f * M_PI / 180.0f;
}


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


void Camera::Precompute() 
{
        mDirection.Normalize();

        //Vector3 side = CrossProd(Vector3(0, 1, 0), mDirection);
        Vector3 side = CrossProd(Vector3(0, 0, 1), mDirection);
        
        mUp = -Normalize(CrossProd(side, mDirection));
        mRight = -Normalize(CrossProd(mDirection, mUp));

        /*float k = tan(mFovy/2);
        mUp *= k;
        mRight *= k*mWidth/mHeight;*/
}


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


void Camera::SetDirection(const Vector3 &dir) 
{
        mDirection = dir;
        Precompute();
}


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


void Camera::LookInBox(const AxisAlignedBox3 &box)
{
        //mDirection = Vector3(0, 0, 1);
        mDirection = Vector3(0, 1, 0);
        mPosition = box.Center();
        mPosition.z = box.Min(2) + 0.9f * box.Size(2);

        Precompute();
}


void Camera::LookAtBox(const AxisAlignedBox3 &box)
{
        mDirection = Vector3(0, box.Min().y - box.Max().y, 0);
        mPosition = Vector3(0);//box.Max() - mDirection;

        Precompute();
}


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

        //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 = mDirection;
        const Vector3 fc = mPosition + view * z_far; 
        
        const Vector3 up = mUp;

        const Vector3 right = mRight;

        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 + mDirection * 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;
}


}