camera.cpp

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
*/

#include "renderstack/camera.hpp"
#include "renderstack/matrix.hpp"
#include "renderstack/viewport.hpp"

namespace renderstack {

camera::camera()
{
    m_near_clip       = 0.1f;
    m_far_clip        = 100.0f;
    m_projection_type = camera_projection_perspective_vertical;
    m_fov             = 90.0f * RS_PI / 180.0f;
}

bool camera::connect(uniform_bindings &bindings, enum logical_uniform uniform, int slot)
{
    switch(uniform)
    {
        case logical_uniform_local_to_clip         : return bindings.add(uniform_type_matrix_4, slot, 1, &frame_to_clip().m[0][0]);
        case logical_uniform_clip_to_local         : return bindings.add(uniform_type_matrix_4, slot, 1, &clip_to_local().m[0][0]);
        case logical_uniform_world_to_clip         : return bindings.add(uniform_type_matrix_4, slot, 1, &world_to_clip().m[0][0]);
        case logical_uniform_clip_to_world         : return bindings.add(uniform_type_matrix_4, slot, 1, &clip_to_world().m[0][0]);
        case logical_uniform_view_position_in_world: return bindings.add(uniform_type_vec3,     slot, 1, &local_to_world().m[3][0]);
        default: 
            return false;
    }
}

void camera::update(viewport const &viewport)
{
    switch(m_projection_type)
    {
        case camera_projection_perspective_horizontal:
        {
            m_local_to_clip = make_matrix_perspective_horizontal(
                m_fov,
                viewport.aspect_ratio(),
                m_near_clip,
                m_far_clip
            );
            break;
        }
        case camera_projection_perspective_vertical:
        {
            m_local_to_clip = make_matrix_perspective_vertical(
                m_fov,
                viewport.aspect_ratio(),
                m_near_clip,
                m_far_clip
            );
            break;
        }
        case camera_projection_orthogonal_horizontal:
        {
            m_local_to_clip = make_matrix_orthogonal_centered(
                m_ortho_width,
                m_ortho_width / viewport.aspect_ratio(),
                m_near_clip,
                m_far_clip
            );
            break;
        }
        case camera_projection_orthogonal_vertical:
        {
            m_local_to_clip = make_matrix_orthogonal_centered(
                m_ortho_height * viewport.aspect_ratio(),
                m_ortho_height,
                m_near_clip,
                m_far_clip
            );
            break;
        }
        case camera_projection_orthogonal:
        {
            m_local_to_clip = make_matrix_orthogonal(
                0,
                m_ortho_width,
                0,
                m_ortho_height,
                m_near_clip, 
                m_far_clip
            );
            break;
        }
        default:
        {
            throw invalid_camera_projection_exception();
        }
    }

    {
        m_clip_to_local = inverse(m_local_to_clip);
    }

    m_world_to_clip = local_to_clip() * world_to_local();
    m_clip_to_world = local_to_world() * clip_to_local();
}

void camera::update_frame(frame const &frame)
{
    m_frame_to_clip   = this->world_to_clip() * frame.local_to_world();
    m_frame_to_camera = this->world_to_local() * frame.local_to_world();
}

}