camera.h

Go to the documentation of this file.

/*
 * camera.h
 *
 * 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.
 *
 *
 * Basic camera object.
 *
 * NOTE: These libraries use a right-handed coordinate system where positive Y
 * is up, and positive X is to the right.  The viewer is then looking at -Z.
 *
 * All angles are in radians unless noted otherwise.
 */

#ifndef WAVE_GLUT_GLUT_CAMERA_H__
#define WAVE_GLUT_GLUT_CAMERA_H__

// includes --------------------------------------------------------------------
#include <math.h>

#include "geometry/placement.h"
#include "perf/perf.h"


namespace glut {

/// \ingroup glut
/*@{*/


// TODO: should this be pulled into a shared library?  Not rendering-specific

/// Class that represents the viewer of a 3D scene.
class Viewer {
public:
        // constructor ---------------------------------------------------------
        Viewer(void) throw();           // starts cleared

        // glut::Viewer public class methods -----------------------------------
        void clear(void) throw();               // position = rotations = zero
        void rotateY(IN float dy) throw();      // rotate around Y axis
        void rotateUp(IN float dz) throw();     // look up/down
        void move(IN float forward, IN float sideways, IN float up) throw();
        void setPosition(IN const point3d_t& pos) throw() { m_position = pos; }
        void setYRotation(IN float rot) throw() { m_yRot = rot; }
        void setUpRotation(IN float rot) throw() { m_upRot = rot; }
        point3d_t getPosition(void) const throw() { return m_position; }
        float getYRotation(void) const throw() { return m_yRot; }
        float getUpRotation(void) const throw() { return m_upRot; }
        point3d_t getFacing(void) const throw();
        point3d_t getUp(void) const throw();

protected:
        // data fields ---------------------------------------------------------
        point3d_t               m_position;
        float                   m_yRot;         // rotation about local y-axis
        float                   m_upRot;        // look up/down
};




/// camera_t : basic physical properties of a camera
struct camera_t {
        // constructor, manipulators -------------------------------------------
        camera_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        fovy = 45.0;            // default
                        aspect = 1.0;
                        zNear = 0.2;
                        zFar = 5000.0;
                }
        float getFovy(void) const throw() { return fovy; }
        float getAspect(void) const throw() { return aspect; }
        float getZNear(void) const throw() { return zNear; }
        float getZFar(void) const throw() { return zFar; }

        void setAspect(IN float a) throw() { aspect = a; }
        void setAspect(IN int width, IN int height) throw()
                {
                        ASSERT(width > 0, "Bad width: %d", width);
                        ASSERT(height > 0, "Bad height: %d", height);
                        this->setAspect((1.0 * width) / height);
                }
        void setZFar(IN float z) throw() { zFar = z; }

protected:
        // data fields ---------------------------------------------------------
        float   fovy;           // field of view, y-axis (DEGREES)
        float   aspect;         // aspect ratio
        float   zNear;          // near clipping plane
        float   zFar;           // far clipping plane
};



// TODO: pull fps_t out of here?   Not glut-specific...

/// fps_t : handy object for frames-per-second calculations
struct fps_t {
        fps_t(void) throw() { }
        fps_t(IN const perf::time_t& startTime) throw() { this->init(startTime); }
        void init(IN const perf::time_t& startTime) throw() {
                        m_startTime = startTime;
                        m_frames = 0;
                        m_fps = 0.0;
                }
        void tick(IN const perf::time_t& currTime) throw() {
                        ++m_frames;
                        perf::time_t delta = currTime;
                        delta.decrement(m_startTime);
                        const float maxDelta = 3.0;
                        float deltaS = delta.getSeconds();
                        if (deltaS >= maxDelta) {
                                m_fps = m_frames / deltaS;
                                m_startTime = currTime;
                                m_frames = 0;
                        }
                }
        float getFPS(void) const throw() { return m_fps; }

        // data fields ---------------------------------------------------------
        perf::time_t    m_startTime;
        long            m_frames;
        float           m_fps;
};


/// getTrailingViewer() -- for over-the-shoulder views
void getTrailingViewer(IN const Viewer& subject,
                        IN float distance_back,
                        OUT Viewer& view) throw();

/// setOpenGLProjection() - set up OpenGL projection transformation
void setOpenGLProjection(IN const camera_t& camera) throw();

/// setOpenGLViewer() - set up initial OpenGL model/view transformation
void setOpenGLViewer(IN const Viewer& viewer) throw();

/// addQuaternionRotation() - rotates current matrix by given quaternion
void addQuaternionRotation(IN const quaternion_t& q) throw();

/// setPlacement() - updates current modelview transformation for placement
void setPlacement(IN const placement_t& p) throw();


};      // glut namespace

#endif  // WAVE_GLUT_GLUT_CAMERA_H__