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

#include "common.h"
#include "Camera.h"
#include "glInterface.h"
#include "Polygon3.h"
#include "Matrix4x4.h"
#include "Polyhedron.h"

namespace CHCDemoEngine 
{

using namespace std;

// our coordinate system is left-handed
// we look into positive y and have the positive z axis pointing up
static const Vector3 baseDir = -Vector3::UNIT_Y();


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

        mPitch = mYaw = 0;
        Precompute(baseDir);

        CalculateFromPitchAndYaw();
}


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

        mIsOrtho = false;

        SetPosition(Vector3::ZERO());

        mPitch = mYaw = 0;
        Precompute(baseDir);

        CalculateFromPitchAndYaw();
}


void Camera::Precompute(const Vector3 &dir) 
{
        Vector3 up = Vector3::UNIT_Z();
        //Vector3 right = Normalize(CrossProd(dir, up));
        //up = Normalize(CrossProd(right, dir));

        //mBaseOrientation = Matrix4x4(right, up, -dir);
        mBaseOrientation = LookAt(Vector3::ZERO(), dir, up);//Matrix4x4(right, up, -dir);
        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)
{
        mat = mViewOrientation;

        // note: left handed system => we go into positive z
        mat.x[3][0] = -DotProd(GetRightVector(), mPosition);
        mat.x[3][1] = -DotProd(GetUpVector(), mPosition);
        mat.x[3][2] = DotProd(GetDirection(), mPosition);
}


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;

        frustum = Frustum(matProjectionView);


        ////////////
        //-- 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
                const float invLength = -1.0f / Magnitude(frustum.mClipPlanes[i].mNormal);
        
                frustum.mClipPlanes[i].mD *= invLength;
                frustum.mClipPlanes[i].mNormal *= invLength;
        }
}


void Camera::SetupCameraView()
{
        Matrix4x4 m;
        GetModelViewMatrix(m);

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


void Camera::ComputePointsInternal(Vector3 &ftl, Vector3 &ftr, Vector3 &fbl, Vector3 &fbr,
                                                                   Vector3 &ntl, Vector3 &ntr, Vector3 &nbl, Vector3 &nbr,
                                                                   const Vector3 &view, const Vector3 &right, const Vector3 &up,
                                                                   const Vector3 &pos,
                                                                   float farthestVisibleDistance) const
{
        float z_near = mNear;
        float z_far = min(mFar, farthestVisibleDistance);

        float fov = mFovy;

        const float aspectRatio = GetAspect();

        const float h_near = tan(fov * 0.5f) * z_near;
        const float w_near = h_near * aspectRatio;

        const float h_far = tan(fov * 0.5f) * z_far;
        const float w_far = h_far * aspectRatio;

        const Vector3 fc = pos + view * z_far; 
        
        Vector3 t1, t2;

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

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

        const Vector3 nc = pos + view * z_near;
        
        t1 = h_near * up;
        t2 = w_near * right;

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


void Camera::ComputePoints(Vector3 &ftl, Vector3 &ftr, Vector3 &fbl, Vector3 &fbr,
                                                   Vector3 &ntl, Vector3 &ntr, Vector3 &nbl, Vector3 &nbr,
                                                   float farthestVisibleDistance) const
{
        ComputePointsInternal(ftl, ftr, fbl, fbr, ntl, ntr, nbl, nbr, 
                                                  GetDirection(), GetRightVector(), GetUpVector(), GetPosition(),
                                                  farthestVisibleDistance);
}


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)
{
        Vector3 ndir = -Normalize(dir);

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

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


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


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


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


Frustum::Frustum(const Matrix4x4 &trafo)
{
        //////////
        //-- extract the plane equations

        for (int i = 0; i < 4; ++ i)
        {
                mClipPlanes[Frustum::RIGHT_PLANE][i] = trafo.x[i][3] - trafo.x[i][0];
                mClipPlanes[Frustum::LEFT_PLANE][i] = trafo.x[i][3] + trafo.x[i][0]; 
                
                mClipPlanes[Frustum::BOTTOM_PLANE][i] = trafo.x[i][3] + trafo.x[i][1];
                mClipPlanes[Frustum::TOP_PLANE][i] = trafo.x[i][3] - trafo.x[i][1]; 

                mClipPlanes[Frustum::FAR_PLANE][i] = trafo.x[i][3] - trafo.x[i][2]; 
                mClipPlanes[Frustum::NEAR_PLANE][i] = trafo.x[i][3] + trafo.x[i][2];
        }
}


void Frustum::EnclosePolyhedron(const Polyhedron &polyhedron)
{
        VertexArray vertices;
        polyhedron.CollectVertices(vertices);

        for (int i = 0; i < 6; ++ i)
        {
                Plane3 &plane = mClipPlanes[i];

                //cout << "p" << i << " " << plane.mD  << endl;

                VertexArray::const_iterator it, it_end = vertices.end();

                float minDist = 1e20;

                for (it = vertices.begin(); it != it_end; ++ it)
                {
                        float dist = plane.Distance(*it);

                        if (dist < minDist)
                        {
                                cout << "minDist: " << dist << endl;
                                minDist = dist;
                        }
                }

                plane.mD += minDist;
        }
}


void Frustum::ExtractTransformation(Matrix4x4 &m) const
{
        for (int i = 0; i < 4; ++ i)
        {
                m.x[i][0] = (mClipPlanes[LEFT_PLANE][i] - mClipPlanes[RIGHT_PLANE][i]) * 0.5f;
                m.x[i][1] = (mClipPlanes[BOTTOM_PLANE][i] - mClipPlanes[TOP_PLANE][i]) * 0.5f;
                m.x[i][2] = (mClipPlanes[NEAR_PLANE][i] - mClipPlanes[FAR_PLANE][i]) * 0.5f;
                m.x[i][3] = (mClipPlanes[LEFT_PLANE][i] + mClipPlanes[RIGHT_PLANE][i]) * 0.5f;
        }
}


Polyhedron *Camera::ComputeFrustum(float farthestVisibleDistance) const
{
        Vector3 ftl, ftr, fbl, fbr;
        Vector3 ntl, ntr, nbl, nbr;

        VertexArray sides[6];

        ComputePoints(ftl, ftr, fbl, fbr, ntl, ntr, nbl, nbr, farthestVisibleDistance);

        for (int i = 0; i < 6; ++ i)
                sides[i].resize(4);
        
        // left, right
        sides[0][0] = ftl; sides[0][1] = fbl; sides[0][2] = nbl; sides[0][3] = ntl;
        sides[1][0] = fbr; sides[1][1] = ftr; sides[1][2] = ntr; sides[1][3] = nbr;
        // bottom, top
        sides[2][0] = fbl; sides[2][1] = fbr; sides[2][2] = nbr; sides[2][3] = nbl;
        sides[3][0] = ftr; sides[3][1] = ftl; sides[3][2] = ntl; sides[3][3] = ntr;
        // near, far
        sides[4][0] = ntr; sides[4][1] = ntl; sides[4][2] = nbl; sides[4][3] = nbr; 
        sides[5][0] = ftl; sides[5][1] = ftr; sides[5][2] = fbr; sides[5][3] = fbl; 


        //////////
        //-- compute polyhedron

        PolygonContainer polygons;

        for (int i = 0; i < 6; ++ i)
        {
                Polygon3 *poly = new Polygon3(sides[i]);
                polygons.push_back(poly);
        }

        return new Polyhedron(polygons);
}


}