OpenRaider/src/Camera.cpp

/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
/*================================================================
 *
 * Project : Freyja
 * Author  : Mongoose
 * Website : http://www.westga.edu/~stu7440/
 * Email   : stu7440@westga.edu
 * Object  : Camera
 * License : No use w/o permission (C) 2001 Mongoose
 * Comments: OpenGL camera class for Freyja
 *
 *           This file was generated using Mongoose's C++
 *           template generator script.  <stu7440@westga.edu>
 *
 *-- History -------------------------------------------------
 *
 * 2002.12.16:
 * Mongoose - Removed perspective setting and OpenGL dependency
 *            API changes to reflect new direction of this object:
 *              Removing outdated algorithms and code
 *              And refactoring the class in general
 *
 * 2001.06.06:
 * Mongoose - Moving GLU code into here to setup break up
 *            into Camera base class, DynamicCamera,
 *            and GLUCamera child classes
 *
 * 2001.06.04:
 * Mongoose - Quaternion based compile option
 *
 * 2001.05.18:
 * Mongoose - Created
 =================================================================*/

#include <stdio.h>
#include <math.h>

#include <MatMath.h>
#include <Camera.h>

#ifdef DEBUG_MEMORY
#include <memory_test.h>
#endif


unsigned int Camera::mCounter = 0;

////////////////////////////////////////////////////////////
// Constructors
////////////////////////////////////////////////////////////

Camera::Camera()
{
    mId = ++mCounter;
    mFlags = 0;
    mViewDistance = 14.0;
    mTranslateDelta = 256.0;
    mRotateDelta = HEL_DEG_TO_RAD(15.0);
    mRotateDelta2 = HEL_DEG_TO_RAD(5.0);
    mFlags &= Camera_FlyMode;
    reset();
}


Camera::~Camera()
{
}


////////////////////////////////////////////////////////////
// Public Accessors
////////////////////////////////////////////////////////////

unsigned int Camera::getId()
{
    return mId;
}


void Camera::getPosition(vec3_t pos)
{
    pos[0] = mPos[0];
    pos[1] = mPos[1];
    pos[2] = mPos[2];
}


void Camera::getUp(vec3_t up)
{
    up[0] = mUp[0];
    up[1] = mUp[1];
    up[2] = mUp[2];
}


void Camera::getTarget(vec3_t target)
{
    target[0] = mTarget[0];
    target[1] = mTarget[1];
    target[2] = mTarget[2];
}


float Camera::getYaw()
{
    return HEL_RAD_TO_DEG(mTheta);
}


double Camera::getRadianYaw()
{
    return mTheta;
}


double Camera::getRadianPitch()
{
    return mTheta2;
}


////////////////////////////////////////////////////////////
// Public Mutators
////////////////////////////////////////////////////////////

void Camera::rotate(float angle, float x, float y, float z)
{
    Quaternion t, n;
    Matrix matrix;
    double side[4] = { 1, 0,  0, 1 };
    double up[4] =   { 0, 1,  0, 1 };
    double look[4] = { 0, 0, -1, 1 };
    unsigned int i;
    matrix_t m;


    t.set(angle, x, y, z);
    n = mQ * t;
    n.normalize();

    n.getMatrix(m);
    matrix.setMatrix(m);
    matrix.multiply4d(side, mSide);
    matrix.multiply4d(look, mTarget);
    matrix.multiply4d(up, mUp);

    for (i = 0; i < 3; ++i)
    {
        mSide[i] += mPos[i];
        mTarget[i] += mPos[i];
        mUp[i] += mPos[i];
    }

    mQ = n;
}


void Camera::translate(float x, float y, float z)
{
    int i;
    double result[4];
    double v[4];
    matrix_t m;
    Matrix matrix;


    v[0] = x;
    v[1] = y;
    v[2] = -z;
    v[3] = 1;

    m[0] = mSide[0] - mPos[0];
    m[1] = mUp[0] - mPos[0];
    m[2] = mTarget[0] - mPos[0];
    m[3] = 0;
    m[4] = mSide[1] - mPos[1];
    m[5] = mUp[1] - mPos[1];
    m[6] = mTarget[1] - mPos[1];
    m[7] = 0;
    m[8] = mSide[2] - mPos[2];
    m[9] = mUp[2] - mPos[2];
    m[10] = mTarget[2] - mPos[2];
    m[11] = 0;
    m[12] = 0;
    m[13] = 0;
    m[14] = 0;
    m[15] = 1;

    matrix.setMatrix(m);
    matrix.multiply4d(v, result);

    for (i = 0; i < 3; ++i)
    {
        mSide[i] += result[i];
        mUp[i] += result[i];
        mTarget[i] += result[i];
        mPos[i] += result[i];
    }

    mPos[0] = x;
    mPos[1] = y;
    mPos[2] = z;
}


void Camera::reset()
{
    mTheta = 0.0;
    mTheta2 = 0.0;

    mPos[0] = 0.0;
    mPos[1] = 0.0;
    mPos[2] = 0.0;

    mTarget[0] = 0.0;
    mTarget[1] = 0.0;
    mTarget[2] = mViewDistance;

    mSide[0] = 1.0;
    mSide[1] = 0.0;
    mSide[2] = 0.0;

    mUp[0] = 0.0;
    mUp[1] = 1.0;
    mUp[2] = 0.0;

    mQ.setIdentity();
    translate(0.0, 0.0, 0.0);
}


void Camera::setSensitivityY(float angle)
{
    mRotateDelta2 = HEL_DEG_TO_RAD(angle);
}


void Camera::setSensitivityX(float angle)
{
    mRotateDelta = HEL_DEG_TO_RAD(angle);
}


////////
void Camera::command(enum camera_command cmd)
{
    switch (cmd)
    {
        case CAMERA_MOVE_FORWARD:
            if (mFlags & Camera_FlyMode)
            {
                mPos[2] += (mTranslateDelta * cos(mTheta));
            }

            mPos[0] += (mTranslateDelta * sin(mTheta));
            mPos[1] += (mTranslateDelta * sin(mTheta2));
            break;
        case CAMERA_MOVE_BACKWARD:
            if (mFlags & Camera_FlyMode)
            {
                mPos[2] -= (mTranslateDelta * cos(mTheta));
            }

            mPos[0] -= (mTranslateDelta * sin(mTheta));
            mPos[1] -= (mTranslateDelta * sin(mTheta2));
            break;
        case CAMERA_MOVE_LEFT:
            mPos[0] -= (mTranslateDelta * sin(mTheta - 90.0f));
            mPos[2] -= (mTranslateDelta * cos(mTheta - 90.0f));
            break;
        case CAMERA_MOVE_RIGHT:
            mPos[0] -= (mTranslateDelta * sin(mTheta + 90.0f));
            mPos[2] -= (mTranslateDelta * cos(mTheta + 90.0f));
            break;
        case CAMERA_ROTATE_UP:
            if (mTheta2 < (M_PI / 2)) {
                mTheta2 += mRotateDelta2;
                rotate(mTheta2, 1.0, 0.0, 0.0);
            }
            break;
        case CAMERA_ROTATE_DOWN:
            if (mTheta2 > -(M_PI / 2)) {
                mTheta2 -= mRotateDelta2;
                rotate(mTheta2, 1.0, 0.0, 0.0);
            }
            break;
        case CAMERA_ROTATE_RIGHT:
            mTheta += mRotateDelta;
            rotate(mTheta, 0.0, 1.0, 0.0);
            break;
        case CAMERA_ROTATE_LEFT:
            mTheta -= mRotateDelta;
            rotate(mTheta, 0.0, 1.0, 0.0);
            break;
        case CAMERA_MOVE_UP:
            mPos[1] -= mTranslateDelta / 2.0;
            mTarget[1] -= mTranslateDelta / 2.0;
            break;
        case CAMERA_MOVE_DOWN:
            mPos[1] += mTranslateDelta / 2.0;
            mTarget[1] += mTranslateDelta / 2.0;
            break;
        case CAMERA_SPEED_UP:
            ++mTranslateDelta;
            break;
        case CAMERA_SPEED_DOWN:
            if (--mTranslateDelta < 0.0)
                mTranslateDelta = 1.0;
            break;
        default:
            ;
    }
}


//! \fixme Mostly invalid for QUAT_CAM (can rotate on XYZ)
bool Camera::isBehind(int x, int z)
{
    double bTheta, bCameraX, bCameraZ, Distance;


    // Set up a "virtual camera" a huge distance behind us
    bTheta = mTheta + HEL_PI;

    if (bTheta > HEL_PI)
        bTheta -= HEL_2_PI;

    // 64k is a fair distance away...
    bCameraX = (65536.0 * sin(bTheta)) + mPos[0];
    bCameraZ = (65536.0 * cos(bTheta)) + mPos[2];

    bCameraX -= x;
    bCameraZ -= z;
    Distance = sqrt((bCameraX * bCameraX) + (bCameraZ * bCameraZ));

    return (Distance < 65536.0);
}


void Camera::setSpeed(float s)
{
    mTranslateDelta = s;
}


void Camera::update()
{
    mTarget[2] = (mViewDistance * cos(mTheta)) + mPos[2];
    mTarget[0] = (mViewDistance * sin(mTheta)) + mPos[0];
    mTarget[1] = (mViewDistance * sin(mTheta2)) + mPos[1]; // + height_offset;
}


void Camera::setPosition(vec3_t pos)
{
    mPos[0] = pos[0];
    mPos[1] = pos[1];
    mPos[2] = pos[2];
}


void Camera::setUp(vec3_t up)
{
    mUp[0] = up[0];
    mUp[1] = up[1];
    mUp[2] = up[2];
}


void Camera::setTarget(vec3_t target)
{
    mTarget[0] = target[0];
    mTarget[1] = target[1];
    mTarget[2] = target[2];
}


////////////////////////////////////////////////////////////
// Private Accessors
////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////
// Private Mutators
////////////////////////////////////////////////////////////