FrameBufferGLX.cc

Go to the documentation of this file.

#include <gra/framebuffer/FrameBufferGLX.h>

using namespace gra;

void FrameBufferGLX::_init(const char * name)
{
    int visualAttr[11] = { GLX_RED_SIZE,   1,
                           GLX_GREEN_SIZE, 1,
                           GLX_BLUE_SIZE,  1,
                           GLX_RGBA, None, None, None, None };
    int i = 7;
    if (!(_fbMode & FB_RGBA))
        cerr << "FrameBufferGLX: Switching to RGBA mode" << endl;
    if (_fbMode & FB_DOUBLE) visualAttr[i++] = GLX_DOUBLEBUFFER;
    if (_fbMode & FB_DEPTH) {
        visualAttr[i++] = GLX_DEPTH_SIZE;
        visualAttr[i++] = 1;
    } else {
        visualAttr[i++] = GLX_DEPTH_SIZE;
        visualAttr[i++] = 0;
    }
    
    _pDisplay    = NULL;
    _pVisualInfo = NULL;
    _pImage      = NULL;

    /* get a connection */
    if (!(_pDisplay = XOpenDisplay(name))) {
        cerr << "FrameBufferGLX: Unable to open X display" << endl;
        return;
    }

    if (! glXQueryExtension(_pDisplay, NULL, NULL)) {
        cerr << "FrameBufferGLX: GLX extension is not supported by X server" << endl;
        return;
    }

    /* get an appropriate visual */
    if (!(_pVisualInfo = glXChooseVisual(_pDisplay,
                                         DefaultScreen(_pDisplay),
                                         visualAttr)))
    {
        cerr << "FrameBufferGLX: Unable to get X visual" << endl;
        return;
    }

    /* set attributes necessary for corrent conversion from our colors to */
    /* display colors                                                     */
    _shiftRed   = ffs(_pVisualInfo->red_mask)   - 1;
    _shiftGreen = ffs(_pVisualInfo->green_mask) - 1;
    _shiftBlue  = ffs(_pVisualInfo->blue_mask)  - 1;

#if BYTE_ORDER == BIG_ENDIAN 
    _byteRev = (ImageByteOrder(_pDisplay) != MSBFirst);
#else
    _byteRev = (ImageByteOrder(_pDisplay) != LSBFirst);
#endif


    /* create a GLX context */
    _context = glXCreateContext(_pDisplay, _pVisualInfo, 0, GL_TRUE);

    /* create a window */
    _winAttr.colormap = XCreateColormap(_pDisplay,
                                        RootWindow(_pDisplay,
                                                   _pVisualInfo->screen),
                                        _pVisualInfo->visual,
                                        AllocNone);
    _winAttr.border_pixel = 0;
    _winAttr.event_mask = StructureNotifyMask;
    _win = XCreateWindow(_pDisplay,
                         RootWindow(_pDisplay, _pVisualInfo->screen),
                         0, 0, _width, _height, 0,
                         _pVisualInfo->depth, InputOutput,
                         _pVisualInfo->visual,
                         CWBorderPixel|CWColormap|CWEventMask,
                         &_winAttr);
    XMapWindow(_pDisplay, _win);
    //XIfEvent(_pDisplay, &_event, WaitForNotify, (char*)_win);

    /* create a graphics context for drawing */
    _gcValues.function = GXcopy;
    _gc = XCreateGC(_pDisplay, _win, GCFunction, &_gcValues);


    /* Allocate and create XImage to save the image if it gets covered */
    if (!(_pImage = XCreateImage(_pDisplay,
                                 _pVisualInfo->visual,
                                 _pVisualInfo->depth,
                                 ZPixmap,
                                 0,
                                 NULL,
                                 _width,
                                 _height,
                                 BitmapPad(_pDisplay),
                                 0)))
    {
        cerr << "FrameBufferGLX: Unable to create X image" << endl;
        return;
    }

    if (!(_pImage->data=(char *)calloc(1, _pImage->bytes_per_line*_height))) {
        cerr << "FrameBufferGLX: Unable to allocate data in the X image" << endl;
        return;
    }

    /* connect the context to the window */
    glXMakeCurrent(_pDisplay, _win, _context);
}

void FrameBufferGLX::_destroy()
{
    if (_pImage) {
        if (_pImage->data) {
            free(_pImage->data);
            _pImage->data = NULL;
        }
        XDestroyImage(_pImage);
        _pImage = NULL;
    }
    if (_winAttr.colormap != None) {
        XFreeColormap(_pDisplay, _winAttr.colormap);
        _winAttr.colormap = None;
    }
    if (_pVisualInfo) {
        XFree(_pVisualInfo);
        _pVisualInfo = NULL;
    }
    if (_pDisplay) {
        XDestroyWindow(_pDisplay, _win);
        glXDestroyContext(_pDisplay, _context);
        XCloseDisplay(_pDisplay);
        _pDisplay = NULL;
    }
}

void FrameBufferGLX::setWidth(unsigned w)
{
    _width = w;

    if (_pDisplay) return;
    
    XResizeWindow(_pDisplay, _win, _width, _height);
    
    if (_pImage) {
        if (_pImage->data) {
            free(_pImage->data);
            _pImage->data = NULL;
        }
        XDestroyImage(_pImage);
        _pImage = NULL;
    }

    /* Allocate and create XImage to save the image if it gets covered */
    if (!(_pImage = XCreateImage(_pDisplay,
                                 _pVisualInfo->visual,
                                 _pVisualInfo->depth,
                                 ZPixmap,
                                 0,
                                 NULL,
                                 _width,
                                 _height,
                                 BitmapPad(_pDisplay),
                                 0)))
    {
        cerr << "FrameBufferGLX::setWidth(): Unable to create X image" << endl;
        return;
    }

    if (!(_pImage->data=(char *)calloc(1, _pImage->bytes_per_line*_height))) {
        cerr << "FrameBufferGLX::setWidth(): Unable to allocate data in the X image" << endl;
        return;
    }
}

void FrameBufferGLX::setHeight(unsigned h)
{
    _height = h;
    
    if (_pDisplay) return;

    XResizeWindow(_pDisplay, _win, _width, _height);

    if (_pImage) {
        if (_pImage->data) {
            free(_pImage->data);
            _pImage->data = NULL;
        }
        XDestroyImage(_pImage);
        _pImage = NULL;
    }

    /* Allocate and create XImage to save the image if it gets covered */
    if (!(_pImage = XCreateImage(_pDisplay,
                                 _pVisualInfo->visual,
                                 _pVisualInfo->depth,
                                 ZPixmap,
                                 0,
                                 NULL,
                                 _width,
                                 _height,
                                 BitmapPad(_pDisplay),
                                 0)))
    {
        cerr << "FrameBufferGLX::setHeight(): Unable to create X image" << endl;
        return;
    }

    if (!(_pImage->data=(char *)calloc(1, _pImage->bytes_per_line*_height))) {
        cerr << "FrameBufferGLX::setHeight(): Unable to allocate data in the X image" << endl;
        return;
    }
}

void FrameBufferGLX::showContent()
{
    if (!_pDisplay || !_pImage) return;
    if (_fbMode & FB_DOUBLE) glXSwapBuffers(_pDisplay, _win);
    XPutImage(_pDisplay, _win, _gc, _pImage, 0, 0, 0, 0,
          _pImage->width, _pImage->height);
    //glFlush();
}

void FrameBufferGLX::setColor(const Camera&  camera,
                              unsigned       x,
                              unsigned       y,
                              float          , // depth is ignored
                              const Color3f& color)
{
    // to do
    cerr << "FrameBufferGLX::setColor(): Depth of pixels is not supported" << endl;
    setColor(camera, x, y, color);
}

void FrameBufferGLX::setColor(const Camera&  , // camera is ignored
                              unsigned       x,
                              unsigned       y,
                              const Color3f& color)
{
    if (!_pVisualInfo || !_pDisplay) return;

    unsigned long r = (unsigned long)(color.x * 255.0);
    unsigned long g = (unsigned long)(color.y * 255.0);
    unsigned long b = (unsigned long)(color.z * 255.0);

    // clip values
    if (r > 255) r = 255;
    if (g > 255) g = 255;
    if (b > 255) b = 255;

    unsigned long pixel =
        ((_byteRev) ?
         (b << _shiftRed) | (g << _shiftGreen) | (r << _shiftBlue) :
         (r << _shiftRed) | (g << _shiftGreen) | (b << _shiftBlue));

    unsigned posy = _height - 1 - y;

    XPutPixel(_pImage, x, posy, pixel);
    XPutImage(_pDisplay, _win, _gc, _pImage, x, posy, x, posy, 1, 1);
}

void FrameBufferGLX::setColors(const Camera& camera,
                               unsigned      x,
                               unsigned      y,
                               float         depth,
                               const Color3f colors[],
                               unsigned      size)
{
    fprintf(stderr,"FrameBufferGL::setColors(): To do");
    // to do
}

void FrameBufferGLX::setColors(const Camera& camera,
                               unsigned      x,
                               unsigned      y,
                               const Color3f colors[],
                               unsigned      size)
{
    unsigned long xpos = x;
    unsigned long ypos = y;

    for (unsigned i = 0; i < size; i++) {
        if (xpos >= _width) { xpos = 0; ypos--; }
        setColor(camera, xpos++, ypos, colors[i]);
    }

    XPutImage(_pDisplay, _win, _gc, _pImage, 0, 0, 0, 0,
              _pImage->width, _pImage->height);
}

Color3f FrameBufferGLX::getColor(unsigned x, unsigned y) const
{
    Color3f c;
    if (!_pImage || !_pVisualInfo) return c;
    
    unsigned long pixel = XGetPixel(_pImage, x, _height-y);

    float r = ((float)((pixel & _pVisualInfo->red_mask) >> _shiftRed) /
               (float)(_pVisualInfo->red_mask >> _shiftRed));
    float g = ((float)((pixel & _pVisualInfo->green_mask) >> _shiftGreen) /
               (float)(_pVisualInfo->green_mask >> _shiftGreen));
    float b = ((float)((pixel & _pVisualInfo->blue_mask) >> _shiftBlue) /
               (float)(_pVisualInfo->blue_mask >> _shiftBlue));

    (_byteRev) ? c.set(b,g,r) : c.set(r,g,b);
    return c;
}

void FrameBufferGLX::clearColor(const Color3f& color)
{
    glClearColor(color.x, color.y, color.z, 1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    if (_fbMode & FB_DOUBLE) glXSwapBuffers(_pDisplay, _win);
}

---