gr_opengl.h

Go to the documentation of this file.

/* $Id: gr_opengl.h 18652 2015-03-16 16:27:26Z ksimek $ */

#ifndef KJB_CPP_OPENGL_H
#define KJB_CPP_OPENGL_H

/*******************************************************************
 *  A collection of functions and classes for using KJB c++ objects
 *  with opengl.
 *
 * In general, the functions below mimick native opengl functions,
 * but use objects instead of opengl primitives.
 *
 * This doesn't include the OpenGL library headers; to get them
 * include gr_cpp/gr_opengl_headers.h
 *
 *******************************************************************/

#include <l_cpp/l_exception.h>
#include <string.h>

//#include <gr_cpp/gr_opengl_headers.h>

namespace kjb
{

class Quaternion;
class Vector;
class Matrix;
class Int_matrix;
class Image;
struct PixelRGBA;

template <size_t D>
class Vector_d;
typedef Vector_d<2> Vector2;
typedef Vector_d<3> Vector3;
typedef Vector_d<4> Vector4;

template <size_t M, size_t N, bool Transposed>
class Matrix_d;
typedef Matrix_d<4,4,false> Matrix4;


namespace opengl
{

/*-----------------------------------------------------------------------------
 *
 * Utility overloads
 *
 * These functions are overloaded versions of standard OpenGL functions.
 *-----------------------------------------------------------------------------*/

void glRotate(const kjb::Quaternion & q);

void glTranslate(const kjb::Vector& p);

void glTranslate(const kjb::Vector3& p);

void glTranslate(const kjb::Vector2& p);

void glVertex(const Vector& p);

void glVertex(const Vector2& p);

void glVertex(const Vector3& p);

void glVertex(const Vector4& p);

void glColor(const Vector& color);

void glColor(const kjb::PixelRGBA& color);

void glColor(const Vector3& color);

void glColor(const Vector4& color);

void glLoadMatrix(const kjb::Matrix& m);

void glLoadMatrix(const kjb::Matrix4& m);

void glMultMatrix(const kjb::Matrix& m);

void glMultMatrix(const kjb::Matrix4& m);

void gluBuild2DMipmaps(const Image& img);

#ifdef KJB_HAVE_OPENGL

void glTexImage2D(unsigned int target, int level, int border, const Image& img);
#endif

void glTexImage2D(const Image& img);

// Why doesn't this use kjb::Matrix's for modelview and projection? --Ernesto (2011/02/17)
//
// This is a thin wrapper for gluUnProject, which is intended to receive matrices received from
// a call to glGetDoublev().  This is called from the higher-level unproject() function.
// Please feel free to overload for kjb::Matrix. -- Kyle (2011/11/16)
//
Vector gluUnProject(const Vector& vertex, double* modelview, double* projection, int* viewport);
Vector3 gluUnProject(const Vector2& vertex, double* modelview, double* projection, int* viewport);
Vector3 gluUnProject(const Vector3& vertex, double* modelview, double* projection, int* viewport);

void gluLookAt(Matrix& M, const Vector& eye, const Vector& target, const Vector& up);


void glOrtho(
        Matrix& state,
        double left,
        double right,
        double bottom,
        double top,
        double znear,
        double zfar);


void glOrtho(
        Matrix4& state,
        double left,
        double right,
        double bottom,
        double top,
        double znear,
        double zfar);


void glClearDepthBuffer();


void glcolormask(bool b1, bool b2, bool b3, bool b4);


void glEnableLineSmooth();


void glDisableLineSmooth();



/*-----------------------------------------------------------------------------
 *  Non-standard OpenGL utility methods.
 *-----------------------------------------------------------------------------*/

void default_init_opengl(unsigned int width = 100, unsigned int height = 100);



size_t get_viewport_width();


size_t get_viewport_height();



Matrix get_modelview_matrix();

Matrix get_projection_matrix();

Vector project(const Vector& x);

Vector2 project(const Vector3& x);

Vector unproject(const Vector& vertex);

void draw_full_screen_quad(float z = 0.0);

bool has_stencil_buffer();

void set_framebuffer(const Image& img);

void set_framebuffer(const Matrix& mat);

void set_framebuffer(const Int_matrix& mat);

Image get_framebuffer_as_image(size_t x, size_t y, size_t width, size_t height);

Image get_framebuffer_as_image();

void get_framebuffer_as_matrix(size_t x, size_t y, size_t width, size_t height, Matrix& out);

void get_depth_buffer_as_matrix
(
    size_t x,
    size_t y,
    size_t width,
    size_t height,
    Matrix& result
);

Matrix get_framebuffer_as_matrix(size_t x, size_t y, size_t width, size_t height);


Matrix get_depth_buffer_as_matrix(size_t x, size_t y, size_t width, size_t height);



Matrix get_framebuffer_as_matrix();


Matrix get_depth_buffer_as_matrix();


Int_matrix get_framebuffer_as_int_matrix(size_t x, size_t y, size_t width, size_t height);

Int_matrix get_framebuffer_as_int_matrix();


void bitmap_string
(
    const std::string& s,
    double x,
    double y,
    void* font = NULL // GLUT_BITMAP_8_BY_13
);

void move_in_plane(kjb::Vector3& plane_pt, const kjb::Vector2& new_pt);

void get_backprojection_line(const Vector2& pt, Vector3& line_pt, Vector3& line_dir);

void render_xz_plane_grid
(
    double xmin,
    double xmax,
    double zmin,
    double zmax,
    double csz = 1.0
);

void render_xy_plane_grid
(
    double xmin,
    double xmax,
    double ymin,
    double ymax,
    double csz = 1.0
);

/*-----------------------------------------------------------------------------
 *  Interface classes
 *-----------------------------------------------------------------------------*/
class Opengl_callable
{
public:
    virtual void gl_call() const = 0;
};

/* --------------------------------------------------------------------------------
 *  ERROR HANDLING
 * --------------------------------------------------------------------------------*/

#ifdef KJB_HAVE_OPENGL

#define GL_ETX()                                             \
    {                                                        \
        GLenum error = glGetError();                         \
        if((error))                                          \
        {                                                    \
            KJB_THROW_2(::kjb::opengl::Opengl_error, error);                \
        }                                                    \
    }

#define GL_EPETE()                                             \
    {                                                        \
        GLenum error = glGetError();                         \
        if((error))                                          \
        {                                                    \
            std:: cout << "Opengl error: " << gluErrorString(error) << std::endl; \
            abort(); \
        }                                                    \
    }

class Opengl_error : public Runtime_error
{
public:
    Opengl_error(unsigned int error_code, const char* file, int line);

    Opengl_error(unsigned int error_code, const std::string& msg, const char* file, int line);

    Opengl_error(const std::string& msg, const char* file, int line);

    unsigned int get_code() { return code_; }
private:
    unsigned int code_;
};
#endif /* #ifdef KJB_HAVE_OPENGL */


}
}

#endif