---

Camera.cc

Go to the documentation of this file.

/*
    File:           Camera.cc

    Function:       See header file

    Author(s):      Andrew Willmott

    Copyright:      (c) 1995-2000, Andrew Willmott
*/

#include "gcl/Camera.h"
#include "gcl/VecUtil.h"
#include "gcl/Quaternion.h"

#ifdef VL_ROW_ORIENT
#error not_implemented
#endif

Camera::Camera() : 
    model(2),
    position(0.0, 1.0, 4.0),
    orient(vl_w),
    scale(1.0),
    clipNear(0.1),
    clipFar(100.0),
    fov(30.0),
    aspect(1.0),
    lhand(false),

    up(vl_y),
    viewDir(0.0, 0.0, -1.0),
    lookAt(0.0, 1.0, 0.0),

    modelCentre(vl_0),
    trans(vl_0),
    rot(vl_0)
{
}

Void Camera::SetClipping(GCLReal nearPlane, GCLReal farPlane)
{
    clipNear = nearPlane;
    clipFar = farPlane;
}

Void Camera::SetFOV(GCLReal fieldOfView)
{
    fov = fieldOfView;
}

Void Camera::SetAspect(GCLReal aspectRatio)
{
    aspect = aspectRatio;
}

Void Camera::SetView(const Point &eyePoint, const Quaternion &q)
{
    position = eyePoint;
    orient = q;
}

Void Camera::SetLookAt(const Point &pos, const Point &at)
{
    position = pos;
    viewDir = at - pos;
    SetupViewDir();
}

Void Camera::SetViewDir(const Point &p, const Vector &dir)
{
    position = p;
    viewDir = dir;
    SetupViewDir();
}

Void Camera::SetViewUp(Vector vup)
{
    up = norm(vup);
    SetupViewDir();
}

Void Camera::SetModelCentric(const Coord &r, const Vector &t)
{
    rot = r;
    trans = t;
    SetupModelCentric();
}

Void Camera::SetScale(GCLReal newScale)
{
    scale = newScale;
}

const GCLReal kProjEpsilon = 0.01;

Void Camera::SetupViewDir()
{
    Vector      xAxis, yAxis, zAxis;
    VecTrans    newOrient;
    
    zAxis = -norm(viewDir);

    xAxis = cross(up, zAxis);
    if (len(xAxis) < kProjEpsilon)
        xAxis = FindOrthoVector(zAxis);

    xAxis.Normalise();
    yAxis = norm(cross(zAxis, xAxis));

    newOrient[0] = xAxis;
    newOrient[1] = yAxis;
    newOrient[2] = zAxis;

    orient = QuatInv(MakeQuat(newOrient));
}

Void Camera::SetupLookAt()
{
    viewDir = lookAt - position;
    SetupViewDir();
}

Void Camera::SetupModelCentric()
// we're looking at the base point; move it about with trans
// rotating scene around it according to rotX and rotY
// base point currently fixed at origin
{
    Point       lookAt = -trans;
    Point       pos = -trans + vl_z;
    Transform   rotn;

    pos *= 4.0;
    lookAt *= 4.0;

    rotn = Rotation(vl_y, -rot[1] * vl_pi) * Rotation(vl_x, -rot[0] * vl_pi);

    pos = xform(rotn, pos);
    lookAt = xform(rotn, lookAt);

    SetLookAt(pos, lookAt);
}

Void Camera::GetViewDirParams()
{
    VecTrans    m;

    m.MakeRot(QuatInv(norm(orient)));
    viewDir = -m[2];
}

Void Camera::GetLookAtParams()
{
    GetViewDirParams();
    lookAt = position + viewDir;
}

Void Camera::GetModelCentricParams()
{
    GetViewDirParams();

    // work backwards from position & viewDir.
    rot[1] = -atan2(-viewDir[0], -viewDir[2]) / vl_pi;
    rot[0] = -asin(viewDir[1]) / vl_pi;
    
    trans = xform(Rotation(vl_x, rot[0] * vl_pi) * Rotation(vl_y, rot[1] * vl_pi),
        position);
    trans = Vector(vl_z) - trans / 4.0;

}


// --- Basic transform routines -----------------------------------------------

Transform Camera::ModelMatrix() const
{
    return(Scalef(scale) * Rotation(QuatInv(norm(orient))) * Shift(-position));
}

Transform Camera::ProjMatrix() const
{
    Transform   project(vl_I);
        
    if (lhand)
    {
        project[3][3] = 0;
        project[2][2] = -(clipFar + clipNear) / (clipFar - clipNear);
        project[2][3] = - 2 * clipFar * clipNear / (clipFar - clipNear);
        project[3][2] = -1;
            
        project[0][0] = 1.0 / tan(DegsToRads(fov));
        project[1][1] = aspect * project[0][0];
    }
    else
    {
        project[3][3] = 0;
        project[2][2] = -(clipFar + clipNear) / (clipFar - clipNear);
        project[2][3] = - 2 * clipFar * clipNear / (clipFar - clipNear);
        project[3][2] = -1;
            
        project[0][0] = 1.0 / tan(DegsToRads(fov));
        project[1][1] = aspect * project[0][0];
    }

    return(project);
}


// --- Avar stuff -------------------------------------------------------------

Void Camera::PrintAvars(Bool animFormat)
{
    cout << "=== quaternion-based: " << endl;
    if (animFormat)
    {
        cout << "k cam_pos_v " << position[0] << ' ' << position[1] << ' ' << position[2] << endl;
        cout << "k cam_orient_q " << orient[0] << ' ' << orient[1] << ' ' << orient[2] << ' ' << orient[3] << endl;
        if (fov != 30.0)
            cout << "k cam_fov " << fov << endl;
    }
    else
    {
        cout << "cam_pos_v " << position[0] << ' ' << position[1] << ' ' << position[2];
        cout << " cam_orient_q " << orient[0] << ' ' << orient[1] << ' ' << orient[2] << ' ' << orient[3];
        if (fov != 30.0)
            cout << " cam_fov " << fov << endl;
        cout << endl;
    }

    cout << "=== camera-based: " << endl;
    if (animFormat)
    {
        cout << "k cam_trans_v " << trans[0] << ' ' << trans[1] << ' ' << trans[2] << endl;
        cout << "k cam_rot_c " << rot[0] << ' ' << rot[1] << endl;
        if (fov != 30.0)
            cout << "k cam_fov " << fov << endl;
    }
    else
    {
        cout << "cam_trans_v " << trans[0] << ' ' << trans[1] << ' ' << trans[2];
        cout << " cam_rot_c " << rot[0] << ' ' << rot[1];
        if (fov != 30.0)
            cout << " cam_fov " << fov << endl;
        cout << endl;
    }
}

Bool Camera::CheckAvar(StrConst avarName, GCLReal avarVal)
{
    // XXX this is a hack for now: later camera params should be part of
    // actual avar mechanism
    if (avarName == "cam_orient_w")
        orient[3] = avarVal;
    else if (avarName.Prefix(-1) == "cam_orient_")
    {
        orient[avarName.Suffix(1)[0] - 'x'] = avarVal;
        model = 0;
    }
    else if (avarName.Prefix(-1) == "cam_pos_")
        position[avarName.Suffix(1)[0] - 'x'] = avarVal;
    else if (avarName == "cam_fov")
        fov = avarVal;
    else if (avarName == "cam_clip_near")
        clipNear = avarVal;
    else if (avarName == "cam_clip_far")
        clipFar = avarVal;
    else if (avarName == "cam_scale")
        scale = avarVal;

    else if (avarName.Prefix(-1) == "cam_dir_")
    {
        viewDir[avarName.Suffix(1)[0] - 'x'] = avarVal;
        model = 1;
    }
    else if (avarName.Prefix(-1) == "cam_vup_")
        up[avarName.Suffix(1)[0] - 'x'] = avarVal;
    else if (avarName.Prefix(-1) == "cam_lookat_")
    {
        lookAt[avarName.Suffix(1)[0] - 'x'] = avarVal;
        model = 2;
    }

    // for backwards-compatibility: deprecated
    else if (avarName.Prefix(-1) == "cam_trans_")
    {
        trans[avarName.Suffix(1)[0] - 'x'] = avarVal;
        model = 3;
    }
    else if (avarName.Prefix(-1) == "cam_rot_")
    {
        rot[avarName.Suffix(1)[0] - 'x'] = avarVal;
        model = 3;
    }
    else if (avarName == "zoom")
        fov = 30.0 / avarVal;
    else
        return(false);

    return(true);
}

Void Camera::SetupFromParams()
{
    if (model == 0)
        ;
    else if (model == 1)
        SetupViewDir();
    else if (model == 2)
        SetupLookAt();
    else if (model == 3)
        SetupModelCentric();
}


// --- Camera utilities -------------------------------------------------------

Void FindWorldRay(
            const Coord     &c,
            const Transform &inverseW2S,
            Point           &from,
            Vector          &dir
        )
{
    HPoint eye(c[0], c[1], 0.0, 1.0);
    HPoint target(c[0], c[1], 1.0, 1.0);    

    eye = inverseW2S * eye;
    target = inverseW2S * target;
    
    from = proj(eye);
    dir = proj(target);
    dir -= from;
}

---