offscreen.cpp

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


#include <jwsc++/config.h>

#include <cstdlib>
#include <cassert>
#include <cstring>
#include <sstream>

#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

#include "jwsc++/graphics/offscreen.h"

#ifdef JWSCXX_HAVE_DMALLOC
#include <dmalloc.h>
#endif


using namespace jwscxx::base;
using namespace jwscxx::graphics;


#if defined JWSCXX_HAVE_X11 && defined JWSCXX_HAVE_GLX
/* -----------------------  GLX_offscreen_buffer  --------------------------- */

void GLX_offscreen_buffer::activate() throw (jwscxx::base::Exception)
{
    if (!active)
    {
        if (!(active = glXMakeCurrent(display, drawable, context)))
        {
            throw jwscxx::base::Exception(
                    "Could not make drawable context current");
        }
    }
}

void GLX_offscreen_buffer::deactivate() throw (jwscxx::base::Exception)
{
    if (active)
    {
        if ((active = !glXMakeCurrent(display, old_drawable, old_context)))
        {
            throw jwscxx::base::Exception(
                    "Could not make old drawable context current");
        }
    }
}

void GLX_offscreen_buffer::reactivate() throw (jwscxx::base::Exception)
{
    if (!active)
    {
        throw jwscxx::base::Exception("No active context to reactivate");
    }
    if (glXMakeCurrent(display, drawable, context))
    {
        throw jwscxx::base::Exception("Could not make context current");
    }
}

void GLX_offscreen_buffer::open_display(const char* disp_name)
    throw(jwscxx::base::Result_error)
{
    display = glXGetCurrentDisplay();

    if (!display)
    {
        display = XOpenDisplay(disp_name);

        if (!display && !disp_name)
        {
            std::ostringstream ost;
            ost << "Could not open X display '" << getenv("DISPLAY") << '\'';
            throw jwscxx::base::Result_error(ost.str());
        }
        else if (!display)
        {
            std::ostringstream ost;
            ost << "Could not open X display '" << disp_name << '\'';
            throw jwscxx::base::Result_error(ost.str());
        }

        display_open = true;
    }
}

void GLX_offscreen_buffer::save_old_context()
{
    // Grab the current drawable and context there might be none, in which case
    // these will be 0.
    old_drawable = glXGetCurrentDrawable();
    old_context = glXGetCurrentContext();
}

/* ---------------------------------------------------------------------------*/







/* -------------------------  GLX_offscreen_pixmap  --------------------------*/

GLX_offscreen_pixmap::GLX_offscreen_pixmap
(
    int  width, 
    int  height, 
    int* attrs
)
throw (jwscxx::base::Exception) : GLX_offscreen_buffer(width, height)
{
    open_display();
    save_old_context();
    create_drawable_and_context(attrs);
}

GLX_offscreen_pixmap::~GLX_offscreen_pixmap()
{
    if (active)
    {
        deactivate();
    }

    glXDestroyContext(display, context);
    destroy_drawable();

    if (display_open)
    {
        XCloseDisplay(display);
    }
}

void GLX_offscreen_pixmap::create_drawable_and_context(int* attrs)
    throw (jwscxx::base::Result_error)
{
    static int default_attrs[] = { GLX_RGBA,
                                   GLX_RED_SIZE,     8,
                                   GLX_GREEN_SIZE,   8,
                                   GLX_BLUE_SIZE,    8,
                                   GLX_ALPHA_SIZE,   8,
                                   GLX_DEPTH_SIZE,   4,
                                   GLX_STENCIL_SIZE, 4,
                                   None };

    if (!attrs)
    {
        attrs = default_attrs;
    }

    XVisualInfo *visual = glXChooseVisual(display, 
            DefaultScreen(display), attrs);
    if (!visual)
    {
        throw jwscxx::base::Result_error("Could not get X visual");
    }

    pixmap = XCreatePixmap(display, DefaultRootWindow(display),
                width, height, visual->depth);
    if (!pixmap)
    {
        throw jwscxx::base::Result_error("Could not create X11 pixmap");
    }

    drawable = glXCreateGLXPixmap(display, visual, pixmap);
    if (!drawable)
    {
        throw jwscxx::base::Result_error("Could not create GLX pixmap");
    }

    context = glXCreateContext(display, visual, 0, GL_FALSE);
    if (!context)
    {
        throw jwscxx::base::Result_error("Could not create GLX context");
    }
}

void GLX_offscreen_pixmap::destroy_drawable()
{
    glXDestroyPixmap(display, drawable);
    XFreePixmap(display, pixmap);
}

/* ---------------------------------------------------------------------------*/






/* -------------------------  GLX_offscreen_pbuffer  -------------------------*/

GLX_offscreen_pbuffer::GLX_offscreen_pbuffer
(
    int  width, 
    int  height, 
    int* attrs
)
throw (jwscxx::base::Exception)
    : GLX_offscreen_buffer(width, height)
{
    open_display();

    if (!has_pbuffer_extension())
    {
        throw jwscxx::base::Result_error("PBuffers not supported");
    }

    save_old_context();
    create_drawable_and_context(attrs);
}

GLX_offscreen_pbuffer::~GLX_offscreen_pbuffer()
{
    if (active)
    {
        deactivate();
    }

    glXDestroyContext(display, context);
    destroy_drawable();

    if (display_open)
    {
        XCloseDisplay(display);
    }
}
    
void GLX_offscreen_pbuffer::create_drawable_and_context(int* attrs)
    throw(jwscxx::base::Exception)
{
    static int default_attrs[] = { GLX_RED_SIZE,     8,
                                   GLX_GREEN_SIZE,   8,
                                   GLX_BLUE_SIZE,    8,
                                   GLX_ALPHA_SIZE,   8,
                                   GLX_DEPTH_SIZE,   4,
                                   GLX_STENCIL_SIZE, 1,
                                   None };

    int pbuf_attrs[] = { GLX_PBUFFER_WIDTH, width, 
                         GLX_PBUFFER_HEIGHT, height,
                         GLX_PRESERVED_CONTENTS, GL_TRUE,
                         None };

    if (!attrs)
    {
        attrs = default_attrs;
    }

    int nlist;
    GLXFBConfig *fbconfig = glXChooseFBConfig(display, DefaultScreen(display),
                attrs, &nlist);
    if (!fbconfig)
    {
        throw jwscxx::base::Result_error("Could not create pbuffer");
    }

    for (int i = 0; i < nlist; i++)
    {
        drawable = glXCreatePbuffer(display, fbconfig[i], pbuf_attrs);

        if (drawable)
        {
            context = glXCreateNewContext(display, fbconfig[i], GLX_RGBA_TYPE,
                    0, GL_TRUE);

            XFree(fbconfig);

            if(!context)
            {
                throw jwscxx::base::Result_error("Could not create context");
            }

            return;
        }
    }

    XFree(fbconfig);

    throw jwscxx::base::Result_error("Could not find valid framebuffer config");
}

void GLX_offscreen_pbuffer::destroy_drawable()
{
    glXDestroyPbuffer(display, drawable);
}

bool GLX_offscreen_pbuffer::has_pbuffer_extension() const
{
    bool has_pbuffer = false;

    const char* ext = glXQueryServerString(display, 0, GLX_EXTENSIONS);
    char* ext_buf = (char*)malloc(strlen(ext)*sizeof(char));
    char* ext_ptr = ext_buf;
    strcpy(ext_ptr, ext);
    ext_ptr = strtok(ext_ptr, " ");
    do
    {
        if (strcmp(ext_ptr, "GLX_SGIX_pbuffer") == 0)
        {
            has_pbuffer = true;
        }
    } while ((ext_ptr = strtok(0, " ")));
    free(ext_buf);

    return has_pbuffer;
}

/* ---------------------------------------------------------------------------*/







#elif defined JWSCXX_HAVE_OPENGL_FRAMEWORK
/* -------------------------  CGL_offscreen_pbuffer  -------------------------*/

CGL_offscreen_pbuffer::CGL_offscreen_pbuffer
(
    GLsizei width, 
    GLsizei height, 
    GLenum  format,
    const CGLPixelFormatAttribute* attrs
)
throw (jwscxx::base::Exception) : Offscreen_buffer(width, height)
{
    save_old_context();
    create_pbuffer_and_context(format, attrs);
}

CGL_offscreen_pbuffer::~CGL_offscreen_pbuffer()
{
    if (active)
    {
        deactivate();
    }

    CGLDestroyContext(context);
    CGLDestroyPBuffer(pbuffer);
}
    
void CGL_offscreen_pbuffer::activate() throw (jwscxx::base::Exception)
{
    if (!active)
    {
        active = !CGLSetCurrentContext(context);
        if (!active)
        {
            throw jwscxx::base::Exception("Could not make context current");
        }
    }
}

void CGL_offscreen_pbuffer::deactivate() throw (jwscxx::base::Exception)
{
    if (active)
    {
        active = CGLSetCurrentContext(old_context);
        if (active)
        {
            throw jwscxx::base::Exception(
                    "Could not make old context current");
        }
    }
}


void CGL_offscreen_pbuffer::reactivate() throw (jwscxx::base::Exception)
{
    if (!active)
    {
        throw jwscxx::base::Exception("No active context to reactivate");
    }
    if (CGLSetCurrentContext(context))
    {
        throw jwscxx::base::Exception("Could not make context current");
    }
}

void CGL_offscreen_pbuffer::create_pbuffer_and_context
(
    GLenum format,
    const CGLPixelFormatAttribute* attrs
)
throw(jwscxx::base::Exception)
{
    static const CGLPixelFormatAttribute default_attrs[] = 
                                      { kCGLPFAColorSize,   
                                        (CGLPixelFormatAttribute)24,
                                        kCGLPFAAlphaSize,   
                                        (CGLPixelFormatAttribute)8,
                                        kCGLPFADepthSize,   
                                        (CGLPixelFormatAttribute)32,
                                        kCGLPFAAccelerated,
                                        kCGLPFAPBuffer,
                                        (CGLPixelFormatAttribute)0 };

    if (!attrs)
    {
        attrs = default_attrs;
    }

    CGLPixelFormatObj pxlfmt;
    GLint nlist;
    if (CGLChoosePixelFormat(attrs, &pxlfmt, &nlist))
    {
        throw jwscxx::base::Result_error("Could not choose pixel format");
    }

    for (int i = 0; i < nlist; i++)
    {
        CGLError err = CGLCreateContext(pxlfmt, 0, &context);

        if (!err)
        {
            break;
        }
        else if (err != kCGLBadPixelFormat || 
                ((nlist - i) == 1 && err == kCGLBadPixelFormat))
        {
            CGLDestroyPixelFormat(pxlfmt);
            throw jwscxx::base::Result_error("Could not create context");
        }
    }

    CGLDestroyPixelFormat(pxlfmt);

    GLint screen;
    if (CGLGetVirtualScreen(context, &screen))
    {
        throw jwscxx::base::Result_error("Could not get virtual screen");
    }

    if (CGLCreatePBuffer(width, height, GL_TEXTURE_RECTANGLE_EXT, format, 0, 
                &pbuffer))
    {
        throw jwscxx::base::Result_error("Could not create pbuffer");
    }

    if (CGLSetPBuffer(context, pbuffer, 0, 0, screen))
    {
        throw jwscxx::base::Result_error("Could not set pbuffer");
    }
}

void CGL_offscreen_pbuffer::save_old_context()
{
    old_context = CGLGetCurrentContext();
}

/* ---------------------------------------------------------------------------*/
#endif





#if defined JWSCXX_HAVE_OSMESA32
/* ----------------------  OSMesa32_offscreen_buffer  ------------------------*/

OSMesa32_offscreen_buffer::OSMesa32_offscreen_buffer
(
    GLsizei width, 
    GLsizei height, 
    GLenum  format,
    GLint   depth_bits,
    GLint   stencil_bits,
    GLint   accum_bits
)
throw (jwscxx::base::Exception) : Offscreen_buffer(width, height)
{
    create_buffer_and_context(format, depth_bits, stencil_bits, accum_bits);
}

OSMesa32_offscreen_buffer::~OSMesa32_offscreen_buffer()
{
    if (active)
    {
        deactivate();
    }

    OSMesaDestroyContext(context);
    free(buffer);
}
    
void OSMesa32_offscreen_buffer::activate() throw (jwscxx::base::Exception)
{
    if (!active)
    {
        if (!(active = OSMesaMakeCurrent(context, buffer, GL_UNSIGNED_BYTE, 
                        width, height)))
        {
            throw jwscxx::base::Exception("Could not make context current");
        }
    }
}

void OSMesa32_offscreen_buffer::deactivate() throw (jwscxx::base::Exception)
{
    if (active)
    {
        active = false;
    }
}

void OSMesa32_offscreen_buffer::reactivate() throw (jwscxx::base::Exception)
{
    if (!active)
    {
        throw jwscxx::base::Exception("No active context to reactivate");
    }
    // Nothing to do.
}

void OSMesa32_offscreen_buffer::create_buffer_and_context
(
    GLenum format,
    GLint  depth_bits,
    GLint  stencil_bits,
    GLint  accum_bits
)
throw(jwscxx::base::Exception)
{
    context = OSMesaCreateContextExt(format, depth_bits, stencil_bits, 
            accum_bits, 0);
    if (!context)
    {
        throw jwscxx::base::Result_error("Could not create context");
    }

    buffer = malloc(width * height * 4 * sizeof(GLbyte));
    if (!buffer)
    {
        throw jwscxx::base::Result_error("Could not create buffer");
    }
}

/* ---------------------------------------------------------------------------*/
#endif