offscreen.h

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#ifndef OFFSCREEN_H
#define OFFSCREEN_H


#include <jwsc++/config.h>

#include <jwsc++/base/exception.h>

#if defined JWSCXX_HAVE_X11 && defined JWSCXX_HAVE_GLX
#include <X11/Xlib.h>
#include <GL/gl.h>
#include <GL/glx.h>
#elif defined JWSCXX_HAVE_OPENGL_FRAMEWORK
#include <OpenGL/OpenGL.h>
#include <OpenGL/gl.h>
#endif

#if defined JWSCXX_HAVE_OSMESA32
#include <GL/osmesa.h>
#endif


namespace jwscxx {
namespace graphics {


class Offscreen_buffer
{
    public:

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

        virtual ~Offscreen_buffer() { }

        virtual void activate() throw(jwscxx::base::Exception) = 0;

        virtual void deactivate() throw(jwscxx::base::Exception) = 0;

        virtual void reactivate() throw(jwscxx::base::Exception) = 0;

    protected:

        bool active;

        int width; 

        int height;
};


#if defined JWSCXX_HAVE_X11 && defined JWSCXX_HAVE_GLX

class GLX_offscreen_buffer : public Offscreen_buffer
{
    public:

        GLX_offscreen_buffer(int width, int height) 
            : Offscreen_buffer(width, height) { display_open = false; }

        virtual ~GLX_offscreen_buffer() { }

        virtual void activate() throw(jwscxx::base::Exception);

        virtual void deactivate() throw(jwscxx::base::Exception);

        virtual void reactivate() throw(jwscxx::base::Exception);

    protected:

        void save_old_context();

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

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

        virtual void destroy_drawable() = 0;

    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(jwscxx::base::Exception);
        
        virtual ~GLX_offscreen_pixmap();

    protected:

        virtual void create_drawable_and_context(int* attrs)
            throw(jwscxx::base::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(jwscxx::base::Exception);

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

        virtual ~GLX_offscreen_pbuffer();

    protected:

        bool has_pbuffer_extension() const;

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

        virtual void destroy_drawable();
};


#elif defined JWSCXX_HAVE_OPENGL_FRAMEWORK

class CGL_offscreen_pbuffer : public Offscreen_buffer
{
    public:

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

        virtual ~CGL_offscreen_pbuffer();

        virtual void activate() throw(jwscxx::base::Exception);

        virtual void deactivate() throw(jwscxx::base::Exception);

        virtual void reactivate() throw(jwscxx::base::Exception);

    protected:

        virtual void save_old_context();

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

    protected:

        CGLContextObj context;

        CGLContextObj old_context;

        CGLPBufferObj pbuffer;
};
#endif


#if defined JWSCXX_HAVE_OSMESA32

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 (jwscxx::base::Exception);

        virtual ~OSMesa32_offscreen_buffer();

        virtual void activate() throw(jwscxx::base::Exception);

        virtual void deactivate() throw(jwscxx::base::Exception);

        virtual void reactivate() throw(jwscxx::base::Exception);

    protected:

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

    protected:

        OSMesaContext context;

        void* buffer;
};
#endif


}}


#endif