camera.cpp

Go to the documentation of this file.

/*
 * camera.cpp
 *
 * Copyright (C) 2008,2009  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Implementation of simple GLUT-based camera.  See camera.h
 */

// includes --------------------------------------------------------------------
#include "camera.h"                     // always include our own header first!

#include "wave-glut.h"


namespace glut {


static const float s_twoPi              = 2.0 * M_PI;


////////////////////////////////////////////////////////////////////////////////
//
/// \ingroup glut
/// \defgroup glut_camera Cameras and OpenGL
///
///
/// Basically, use GL_PROJECTION to set up the camera properties but NOT
/// position or rotation.  Use GL_MODELVIEW for those transformations.
///
/// \n
/// From http://www.opengl.org/resources/faq/technical/viewing.htm :
///
/// The GL_PROJECTION matrix should contain only the projection transformation
/// calls it needs to transform eye space coordinates into clip coordinates.
///
/// The GL_MODELVIEW matrix, as its name implies, should contain modeling and
/// viewing transformations, which transform object space coordinates into eye
/// space coordinates.  Remember to place the camera transformations on the
/// GL_MODELVIEW matrix and never on the GL_PROJECTION matrix.
///
/// Think of the projection matrix as describing the attributes of your camera,
/// such as field of view, focal length, fish eye lens, etc. Think of the
/// ModelView matrix as where you stand with the camera and the direction you
/// point it.
///
///
/// \n
/// From http://sjbaker.org/steve/omniv/projection_abuse.html :
///
/// One of the most common OpenGL programming errors is misuse of the
/// GL_PROJECTION matrix stack. This matrix stack is often perceived as being
/// the correct place to put the position and orientation of the 'camera' -
/// but this is not in fact the case...
///
/// The Golden Rule.
/// The rule is:
///
/// <em>The only functions that should be called when the
///     glMatrixMode is set to GL_PROJECTION are:</em>
///
/// - glLoadIdentity - to initialise the stack.
/// - gluPerspective/glFrustum/glOrtho/gluOrtho2 -
///               to set the appropriate projection onto the stack.
///
//
////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////
//
//      Viewer implementation
//
////////////////////////////////////////////////////////////////////////////////

Viewer::Viewer(void)
throw()
{
        this->clear();
}



void
Viewer::clear
(
void
)
throw()
{
        m_position.clear();
        m_yRot = m_upRot = 0.0;
}



void
Viewer::rotateY
(
IN float dy
)
throw()
{
        m_yRot += dy;

        // keep y-rotation in range 0 <= y_rot <= 2 PI
        if (m_yRot < 0.0) {
                m_yRot += s_twoPi;
        } else if (m_yRot > s_twoPi) {
                m_yRot -= s_twoPi;
        }
}



void
Viewer::rotateUp
(
IN float dz
)
throw()
{
        m_upRot += dz;

        // keep z-rotation in range - PI/2 <= z_rot <= +PI/2
        const float maxUpRot = 0.49 * M_PI;
        if (m_upRot < -maxUpRot) {
                m_upRot = -maxUpRot;
        } else if (m_upRot > maxUpRot) {
                m_upRot = maxUpRot;
        }
}



void
Viewer::move
(
IN float forwards,
IN float sideways,
IN float up
)
throw()
{
        m_position.x += -forwards * sin(m_yRot) - sideways * cos(m_yRot);
        m_position.z += -forwards * cos(m_yRot) + sideways * sin(m_yRot);
        m_position.y += up;
}



point3d_t
Viewer::getFacing
(
void
)
const
throw()
{
        point3d_t facing;

        facing.x = sin(m_yRot) * cos(m_upRot);
        facing.y = sin(m_upRot);
        facing.z = cos(m_yRot) * cos(m_upRot);

        return facing;
}



point3d_t
Viewer::getUp
(
void
)
const
throw()
{
        point3d_t up;

        up.x = sin(m_yRot) * sin(m_upRot);
        up.y = cos(m_upRot);
        up.z = cos(m_yRot) * sin(m_upRot);

        return up;
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

void
getTrailingViewer
(
IN const Viewer& subject,
IN float dist,
OUT Viewer& view
)
throw()
{
        ASSERT(dist > 0.0, "Bad trailing distance: %f", dist);

        point3d_t pos = subject.getPosition();
        point3d_t facing = subject.getFacing();

        pos.x += -dist * facing.x;
        pos.y += -dist * facing.y;
        pos.z += -dist * facing.z;

        view.clear();
        view.setPosition(pos);
        view.rotateY(subject.getYRotation());
        view.rotateUp(subject.getUpRotation());
}



void
setOpenGLProjection
(
IN const camera_t& camera
)
throw()
{
        // see the big comment block above.
        //      GL_PROJECTION: basic camera properties
        //      GL_MODELVIEW:  camera position + rotation (inverted)

        // set up the projection matrix
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(camera.getFovy(),
                       camera.getAspect(),
                       camera.getZNear(),
                       camera.getZFar());
}



void
setOpenGLViewer
(
IN const Viewer& viewer
)
throw()
{
        // which way is up?
        point3d_t up(0, 1, 0);

        // where are we?
        point3d_t position = viewer.getPosition();

        // where are we looking?
        point3d_t facing = viewer.getFacing();
        facing.increment(position);     // looking at this point

        // set up transformation
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(position.x, position.y, position.z,
                  facing.x, facing.y, facing.z,
                  up.x, up.y, up.z);
}



void
addQuaternionRotation
(
IN const quaternion_t& q
)
throw()
{
        // first convert quaternion into OpenGL column-major 4x4 matrix
        // see http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=Quaternion_Camera_Class
        // or http://gpwiki.org/index.php/OpenGL:Tutorials:Using_Quaternions_to_represent_rotation
        // for examples
        // Watch out for row-major vs. column-major representations! 
        // We want column-major.
        // Note on 10 aug 09: I flipped back to row-major!  I must have mis-copied
        //   one of the above sources.
        float m[16];    // 4x4 matrix

        // first row
        m[ 0] = 1.0 - 2.0 * (q.y * q.y + q.z * q.z);
        m[ 4] = 2.0 * (q.x * q.y - q.z * q.w);
        m[ 8] = 2.0 * (q.x * q.z + q.y * q.w);
        m[12] = 0.0;

        // second row
        m[ 1] = 2.0 * (q.x * q.y + q.w * q.z);
        m[ 5] = 1.0 - 2.0 * (q.x * q.x + q.z * q.z);
        m[ 9] = 2.0 * (q.y * q.z - q.w * q.x);
        m[13] = 0.0;

        // third row
        m[ 2] = 2.0 * (q.x * q.z - q.w * q.y);
        m[ 6] = 2.0 * (q.y * q.z + q.w * q.x);
        m[10] = 1.0 - 2.0 * (q.x * q.x + q.y * q.y);
        m[14] = 0.0;

        // fourth row
        m[ 3] = 0.0;
        m[ 7] = 0.0;
        m[11] = 0.0;
        m[15] = 1.0;

        // okay, multiply current OpenGL matrix
        glMultMatrixf(m);
}



void
setPlacement
(
IN const placement_t& p
)
throw()
{
        glMatrixMode(GL_MODELVIEW);
        glTranslatef(p.position.x, p.position.y, p.position.z);
        addQuaternionRotation(p.rotation);
}



};      // glut namespace