glut_perspective_camera.h

Go to the documentation of this file.

/* =========================================================================== *
|
|  Copyright (c) 1994-2008 by Kobus Barnard (author).
|
|  Personal and educational use of this code is granted, provided that this
|  header is kept intact, and that the authorship is not misrepresented, that
|  its use is acknowledged in publications, and relevant papers are cited.
|
|  For other use contact the author (kobus AT cs DOT arizona DOT edu).
|
|  Please note that the code in this file has not necessarily been adequately
|  tested. Naturally, there is no guarantee of performance, support, or fitness
|  for any particular task. Nonetheless, I am interested in hearing about
|  problems that you encounter.
|
| Authors:
|     Luca Del Pero
|
* =========================================================================== */


#ifndef GLUT_PERSPECTIVE_CAMERA_H_
#define GLUT_PERSPECTIVE_CAMERA_H_

#include <gr_cpp/gr_opengl.h>

#ifdef KJB_HAVE_GLUT
#ifdef MAC_OSX
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#endif

enum { GLUT_PC_CENTRE_X, GLUT_PC_CENTRE_Y, GLUT_PC_CENTRE_Z, GLUT_PC_PITCH, GLUT_PC_YAW, GLUT_PC_ROLL,
       GLUT_PC_FOCAL_LENGTH, GLUT_PC_PRINCIPAL_POINT_X, GLUT_PC_PRINCIPAL_POINT_Y, GLUT_PC_SKEW, GLUT_PC_ASPECT_RATIO,
       GLUT_PC_WORLD_SCALE, GLUT_PC_NEAR, GLUT_PC_FAR, GLUT_PC_WIDTH, GLUT_PC_HEIGHT};

#define GLUT_PC_DECREMENT_CHARACTER 'j'
#define GLUT_PC_INCREMENT_CHARACTER 'k'
#define GLUT_PC_NUMBER_OF_CAMERA_PARAMETERS 16

#include <m_cpp/m_vector.h>
#include <camera_cpp/perspective_camera.h>

namespace kjb{

    class Glut_perspective_camera
    {
    public:
        static int create_glut_perspective_camera_submenu(void (*icamera_submenu_callback)(int i), kjb::Perspective_camera * pc,
                bool enable_translation = true, bool enable_pitch = true, bool enable_yaw = true, bool enable_roll = true,
                bool enable_focal_length = true, bool enable_principal_point = true, bool enable_skew = true,
                bool enable_aspect_ratio = true, bool enable_world_scale = true, bool enable_clipping = true,
                bool enable_viewport = true, bool icentre_when_scaling_viewport = true,
                unsigned char iincrement_char = GLUT_PC_INCREMENT_CHARACTER,
                unsigned char idecrement_char = GLUT_PC_DECREMENT_CHARACTER);

        static void camera_submenu_glut(int i);

        static void keyboard_callback(unsigned char key);

        static void enable_camera() {camera_enabled = true;}

        static void disable_camera() {camera_enabled = false;}

        static double retrieve_translation_x_increment() { return increment_steps(GLUT_PC_CENTRE_X);}
        static double retrieve_translation_y_increment() { return increment_steps(GLUT_PC_CENTRE_Y);}
        static double retrieve_translation_z_increment() { return increment_steps(GLUT_PC_CENTRE_Z);}
        static double retrieve_pitch_increment() { return increment_steps(GLUT_PC_PITCH);}
        static double retrieve_yaw_increment() { return increment_steps(GLUT_PC_YAW);}
        static double retrieve_roll_increment() { return increment_steps(GLUT_PC_ROLL);}
        static double retrieve_focal_length_increment() { return increment_steps(GLUT_PC_FOCAL_LENGTH);}
        static double retrieve_principal_point_x_increment() { return increment_steps(GLUT_PC_PRINCIPAL_POINT_X);}
        static double retrieve_principal_point_y_increment() { return increment_steps(GLUT_PC_PRINCIPAL_POINT_Y);}
        static double retrieve_skew_increment() { return increment_steps(GLUT_PC_SKEW);}
        static double retrieve_aspect_ratio_increment() { return increment_steps(GLUT_PC_ASPECT_RATIO);}
        static double retrieve_world_scale_increment() { return increment_steps(GLUT_PC_WORLD_SCALE);}
        static double retrieve_near_clipping_increment() {return increment_steps(GLUT_PC_NEAR);}
        static double retrieve_far_clipping_increment() {return increment_steps(GLUT_PC_FAR);}
        static double retrieve_width_increment() {return increment_steps(GLUT_PC_WIDTH);}
        static double retrieve_height_increment() {return increment_steps(GLUT_PC_HEIGHT);}

        static void update_translation_x_increment(double iincrement) { increment_steps(GLUT_PC_CENTRE_X) = iincrement;}
        static void update_translation_y_increment(double iincrement) { increment_steps(GLUT_PC_CENTRE_Y) = iincrement;}
        static void update_translation_z_increment(double iincrement) { increment_steps(GLUT_PC_CENTRE_Z) = iincrement;}
        static void update_pitch_increment(double iincrement) { increment_steps(GLUT_PC_PITCH) = iincrement;}
        static void update_yaw_increment(double iincrement) { increment_steps(GLUT_PC_YAW) = iincrement;}
        static void update_roll_increment(double iincrement) { increment_steps(GLUT_PC_ROLL) = iincrement;}
        static void update_focal_length_increment(double iincrement) { increment_steps(GLUT_PC_FOCAL_LENGTH) = iincrement;}
        static void update_principal_point_x_increment(double iincrement) { increment_steps(GLUT_PC_PRINCIPAL_POINT_X) = iincrement;}
        static void update_principal_point_y_increment(double iincrement) { increment_steps(GLUT_PC_PRINCIPAL_POINT_Y) = iincrement;}
        static void update_skew_increment(double iincrement) { increment_steps(GLUT_PC_SKEW) = iincrement;}
        static void update_aspect_ratio_increment(double iincrement) { increment_steps(GLUT_PC_ASPECT_RATIO) = iincrement;}
        static void update_world_scale_increment(double iincrement) { increment_steps(GLUT_PC_WORLD_SCALE) = iincrement;}
        static void update_near_clipping_increment(double iincrement) { increment_steps(GLUT_PC_NEAR) = iincrement;}
        static void update_far_clipping_increment(double iincrement) { increment_steps(GLUT_PC_FAR) = iincrement;}
        static void update_width_increment(double iincrement){ increment_steps(GLUT_PC_WIDTH) = iincrement;}
        static void update_height_increment(double iincrement) { increment_steps(GLUT_PC_HEIGHT) = iincrement;}

    private:
        static bool camera_enabled;
        static unsigned int selected_parameter;
        static kjb::Perspective_camera * camera;
        static unsigned char increment_character;
        static unsigned char decrement_character;
        static kjb::Vector increment_steps;

        static bool centre_when_scaling_viewport;
    };
}
static void (*camera_submenu_callback)(int i);

#endif