camera.hpp

Go to the documentation of this file.

/*
    RenderStack  Support library for OpenGL 3+
    Copyright (C) 2010  Timo Suoranta

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CAMERA_HPP
#define CAMERA_HPP

#include "renderstack/rs.h"
#include "renderstack/frame.hpp"
#include <exception>

namespace renderstack {

class viewport;

class invalid_camera_projection_exception 
:   public std::exception
{
};

enum camera_projection
{
    camera_projection_perspective_horizontal = 1,
    camera_projection_perspective_vertical,
    camera_projection_orthogonal_horizontal,
    camera_projection_orthogonal_vertical,
    camera_projection_orthogonal
};

class camera
:   public frame
{
public:
    camera();

    void update(viewport const &viewport);
    void update_frame(frame const &frame);

public:
    bool connect(uniform_bindings &bindings, enum logical_uniform uniform, int slot);

    void set_near_clip       (float                  v ) { m_near_clip = v; }
    void set_far_clip        (float                  v ) { m_far_clip = v; }
    void set_projection_type (enum camera_projection v ) { m_projection_type = v; }
    void set_fov             (float                  angle_radians ) { m_fov = angle_radians; }
    void set_ortho_width     (float                  v ) { m_ortho_width = v; }
    void set_ortho_height    (float                  v ) { m_ortho_height = v; }

    float                   near_clip      () const { return m_near_clip; }
    float                   far_clip       () const { return m_far_clip; }
    enum camera_projection  projection_type() const { return m_projection_type; }
    float                   fov            () const { return m_fov; }
    float                   ortho_width    () const { return m_ortho_width; }
    float                   ortho_height   () const { return m_ortho_height; }

    matrix const        &frame_to_clip  () const { return m_frame_to_clip; }
    matrix const        &frame_to_camera() const { return m_frame_to_camera; }
    matrix const        &world_to_clip  () const { return m_world_to_clip; }
    matrix const        &clip_to_world  () const { return m_clip_to_world; }
    matrix const        &clip_to_local  () const { return m_clip_to_local; }
    matrix const        &local_to_clip  () const { return m_local_to_clip; }

    matrix              &frame_to_clip  () { return m_frame_to_clip; }
    matrix              &frame_to_camera() { return m_frame_to_camera; }
    matrix              &world_to_clip  () { return m_world_to_clip; }
    matrix              &clip_to_world  () { return m_clip_to_world; }
    matrix              &clip_to_local  () { return m_clip_to_local; }
    matrix              &local_to_clip  () { return m_local_to_clip; }

private:
    float               m_near_clip;
    float               m_far_clip;
    camera_projection   m_projection_type;
    float               m_fov;
    float               m_ortho_width;
    float               m_ortho_height;

    matrix              m_frame_to_clip;
    matrix              m_frame_to_camera;
    matrix              m_world_to_clip;
    matrix              m_clip_to_world;
    matrix              m_clip_to_local;    /*  clip to camera(view), aka. inverse projection  */ 
    matrix              m_local_to_clip;    /*  camera(view) to clip, aka. projection  */ 
};

}

#endif