gr_offscreen.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:
|     Joseph Schlecht, Luca Del Pero
|
* =========================================================================== */

#ifndef KJB_GR_OFFSCREEN_H
#define KJB_GR_OFFSCREEN_H

#include <l_cpp/l_exception.h>
#include <gr_cpp/gr_opengl_headers.h>

#ifdef KJB_HAVE_X11
#ifdef KJB_HAVE_OPENGL
#ifndef MAC_OSX

#ifdef KJB_HAVE_OSMESA
#include <GL/osmesa.h>
#else
#include <X11/Xlib.h>
#include <GL/gl.h>
#include <GL/glx.h>
#endif

#else
#include <OpenGL/gl.h>
#include <OpenGL/OpenGL.h>
#endif

#endif
#endif



namespace kjb {


void retrieve_offscreen_capabilities(bool *_has_gl, bool *_has_osmesa);

bool supports_pbuffers();

bool supports_pixmaps();

class Offscreen_buffer
{
    public:

        Offscreen_buffer(int iwidth, int iheight)
        { this->width = iwidth; this->height = iheight; active = false; }

        virtual ~Offscreen_buffer() { }

        virtual void activate() throw(kjb::Exception) = 0;

        virtual void deactivate() throw(kjb::Exception) = 0;

        virtual void reactivate() throw(kjb::Exception) = 0;

    protected:

        bool active;

        int width; 

        int height;
};


#if defined KJB_HAVE_X11 && defined KJB_HAVE_OPENGL
#ifndef KJB_HAVE_OSMESA
#ifndef MAC_OSX

class GLX_offscreen_buffer : public Offscreen_buffer
{
    public:

        GLX_offscreen_buffer(int iwidth, int iheight)
            : Offscreen_buffer(iwidth, iheight) { display_open = false; }

        virtual ~GLX_offscreen_buffer() { }

        virtual void activate() throw(kjb::Exception);

        virtual void deactivate() throw(kjb::Exception);

        virtual void reactivate() throw(kjb::Exception);

    protected:

        void save_old_context();

        void open_display(const char* disp_name=0) 
            throw(kjb::Result_error);

        virtual void create_drawable_and_context(int* attrs)
            throw(kjb::Exception) = 0;

        virtual void destroy_drawable() = 0;

        bool has_pbuffer_extension() const;

        bool has_pixmap_extension() const;

    protected:

        bool display_open;

        Display* display;

        GLXDrawable  drawable;
        
        GLXDrawable old_drawable;

        GLXContext context;

        GLXContext old_context;
};


class GLX_offscreen_pixmap : public GLX_offscreen_buffer
{
    public:

        GLX_offscreen_pixmap(int width, int height, int* attrs=0)
            throw(kjb::Exception);
        
        virtual ~GLX_offscreen_pixmap();

    protected:

        virtual void create_drawable_and_context(int* attrs)
            throw(kjb::Result_error);

        virtual void destroy_drawable();

    protected:

        Pixmap pixmap;
};


class GLX_offscreen_pbuffer : public GLX_offscreen_buffer
{
    public:

        GLX_offscreen_pbuffer(int width, int height)
            throw(kjb::Exception);

        GLX_offscreen_pbuffer(int width, int heigth, int* attrs)
            throw (kjb::Exception);

        virtual ~GLX_offscreen_pbuffer();

    protected:

        virtual void create_drawable_and_context(int* attrs)
            throw(kjb::Exception);

        virtual void destroy_drawable();
};


#else

class CGL_offscreen_pbuffer : public Offscreen_buffer
{
    public:

        CGL_offscreen_pbuffer
        (
            GLsizei width, 
            GLsizei height, 
            GLenum  format=GL_RGBA,
            const CGLPixelFormatAttribute* attrs=0
        )
        throw (kjb::Exception);

        virtual ~CGL_offscreen_pbuffer();

        virtual void activate() throw(kjb::Exception);

        virtual void deactivate() throw(kjb::Exception);

        virtual void reactivate() throw(kjb::Exception);

    protected:

        virtual void save_old_context();

        virtual void create_pbuffer_and_context
        (
            GLenum format,
            const CGLPixelFormatAttribute* attrs
        )
        throw(kjb::Exception);

    protected:

        CGLContextObj context;

        CGLContextObj old_context;

        CGLPBufferObj pbuffer;
};
#endif
#endif
#endif

#ifdef KJB_HAVE_OSMESA

class OSMesa32_offscreen_buffer : public Offscreen_buffer
{
    public:

        OSMesa32_offscreen_buffer
        (
            GLsizei width, 
            GLsizei height, 
            GLenum  format=OSMESA_RGBA,
            GLint   depth_bits=4,
            GLint   stencil_bits=4,
            GLint   accum_bits=4
        )
        throw (kjb::Exception);

        virtual ~OSMesa32_offscreen_buffer();

        virtual void activate() throw(kjb::Exception);

        virtual void deactivate() throw(kjb::Exception);

        virtual void reactivate() throw(kjb::Exception);

    protected:

        virtual void create_buffer_and_context
        (
            GLenum format,
            GLint  depth_bits,
            GLint  stencil_bits,
            GLint  accum_bits
        )
        throw(kjb::Exception);

    protected:

        OSMesaContext context;

        void* buffer;
};
#endif

#ifdef KJB_HAVE_OPENGL

Offscreen_buffer * create_default_offscreen_buffer
(
    GLsizei iwidth,
    GLsizei iheight,
    bool use_pbuffers_when_available = true
);

Offscreen_buffer * create_and_initialize_offscreen_buffer
(
    unsigned int width,
    unsigned int height,
    bool use_pbuffers_when_available = true
);

#endif

}


#endif