Subversion Repositories seema-scanner

#include "OpenGLContext.h"

#include <GL/gl.h>
#include <GL/glx.h>
#include <X11/Xlib.h>
#include <X11/Xcursor/Xcursor.h>

#include <stdio.h>
#include <string.h>

#include <unistd.h>

// vmode extension for mode settings, gamma control, etc.
#include <X11/extensions/xf86vmode.h>

// XRandR extension for virtual screens, mode setting, etc.
#include <X11/extensions/Xrandr.h>

struct OpenGLContext::OpenGLContextInfo{
    Display *display;
    Window window;
    GLXContext context;
    OpenGLContextInfo() : display(NULL), window(0), context(NULL){}
};

std::vector<ScreenInfo> OpenGLContext::GetScreenInfo(){
    std::vector<ScreenInfo> ret;

    // Connection to default X Server
    Display *display = XOpenDisplay(NULL);

    RROutput primaryOutput = XRRGetOutputPrimary(display, RootWindow(display, 0));
    XRRScreenResources* sr = XRRGetScreenResources(display, RootWindow(display, 0));

    // number of virtual (XRandr screens)
    unsigned int nVirtualScreens = sr->ncrtc;

    for (unsigned int j = 0;  j < nVirtualScreens;  j++){
        XRROutputInfo* oi;
        XRRCrtcInfo* ci;
        RROutput output;

        // check if the crt has outputs
        ci = XRRGetCrtcInfo(display, sr, sr->crtcs[j]);
        if (ci->noutput == 0){
            XRRFreeCrtcInfo(ci);
            continue;
        }

        output = ci->outputs[0];

        // if primaryoutput is among outputs, use that instead of the first
        for (int k = 0;  k < ci->noutput;  k++){
            if (ci->outputs[k] == primaryOutput){
                output = primaryOutput;
                break;
            }
        }

        // check that the output is connected
        oi = XRRGetOutputInfo(display, sr, output);
        if(oi->connection != RR_Connected){
            XRRFreeOutputInfo(oi);
            XRRFreeCrtcInfo(ci);
            continue;
        }

        ScreenInfo info;
        info.name = oi->name;

        // get current mode
        XRRModeInfo *modeInfo;
        for (int k = 0;  k < sr->nmode;  k++){
            if (sr->modes[k].id == ci->mode){
                modeInfo = sr->modes + k;
                break;
            }
        }

        info.resX = modeInfo->width;
        info.resY = modeInfo->height;

        info.posX = ci->x;
        info.posY = ci->y;

        ret.push_back(info);
    }
    XRRFreeScreenResources(sr);

    XCloseDisplay(display);

    return ret;
}


OpenGLContext::OpenGLContext(uint _screenNum) : screenNum(_screenNum){

    std::vector<ScreenInfo> virtualScreens = GetScreenInfo();
    if(screenNum > virtualScreens.size())
        std::cerr << "OpenGLContext: cannot open screen no. " << screenNum << "!" << std::endl;

    ScreenInfo screen = virtualScreens[screenNum];
    screenResX = screen.resX;
    screenResY = screen.resY;

    contextInfo = new OpenGLContextInfo();
    contextInfo->display = XOpenDisplay(NULL);

    int attrListDbl[] = {
        GLX_RGBA, GLX_DOUBLEBUFFER,
        GLX_RED_SIZE, 4,
        GLX_GREEN_SIZE, 4,
        GLX_BLUE_SIZE, 4,
        None
    };

    XVisualInfo *visualInfo = glXChooseVisual(contextInfo->display, 0, attrListDbl);

    int glxMajor, glxMinor = 0;
    glXQueryVersion(contextInfo->display, &glxMajor, &glxMinor);
    std::cout << "GLX-Version " << glxMajor << "." << glxMinor << std::endl;

    // Create a GLX OpenGLContext
    bool directRendering = True;
    contextInfo->context = glXCreateContext(contextInfo->display, visualInfo,  NULL, directRendering);

    // Check if OpenGLContext is direct
    if (glXIsDirect(contextInfo->display, contextInfo->context))
        std::cout << "OpenGLContext is direct." << std::endl;
    else
        std::cout << "OpenGLContext is not direct." << std::endl;

    // Create colormap
    Colormap colormap = XCreateColormap(contextInfo->display, RootWindow(contextInfo->display, 0), visualInfo->visual, AllocNone);

    // Create the actual window
    unsigned long wamask = CWColormap;

    XSetWindowAttributes wa;
    wa.colormap = colormap;
    wa.border_pixel = 0;
    wa.event_mask = 0;

    // bypass window manager (has no effect here)
    wa.override_redirect = True;

    // show no cursor
    wa.cursor = None;

    contextInfo->window = XCreateWindow(contextInfo->display, RootWindow(contextInfo->display, 0), screen.posX, screen.posY, screenResX, screenResY, 0, visualInfo->depth, InputOutput, visualInfo->visual, wamask, &wa);

    // move to correct position (necessary when not overriding redirect)
    XMoveWindow(contextInfo->display, contextInfo->window, screen.posX, screen.posY);

    if(!contextInfo->window)
        std::cerr << "Failed to create X window!" << std::endl;

    // bypass window manager (actually effects here)
    XSetWindowAttributes attributes;
    attributes.override_redirect = False;
    XChangeWindowAttributes(contextInfo->display, contextInfo->window, CWOverrideRedirect, &attributes);

    // Disable mouse cursor over window
    XcursorImage *cursorImage = XcursorImageCreate(1, 1);
    *cursorImage->pixels = 0;
    cursorImage->xhot = 0;
    cursorImage->yhot = 0;
    Cursor cursor = XcursorImageLoadCursor(contextInfo->display, cursorImage);
    XDefineCursor(contextInfo->display, contextInfo->window, cursor);
    XFreeCursor(contextInfo->display, cursor);

    // Connect the glx-OpenGLContext to the window
    glXMakeCurrent(contextInfo->display, contextInfo->window, contextInfo->context);

    // Window state
    Atom wmNetWmState = XInternAtom(contextInfo->display, "_NET_WM_STATE", 1);
    // raise window above most other windows
    Atom wmStateAbove = XInternAtom(contextInfo->display, "_NET_WM_STATE_ABOVE", 1);
    // define window as fullscreen
    Atom wmStateFullScreen = XInternAtom(contextInfo->display, "_NET_WM_STATE_FULLSCREEN", 1);

    XEvent event;
    memset(&event, 0, sizeof(event));

    event.type = ClientMessage;
    event.xclient.window = contextInfo->window;
    event.xclient.format = 32; // Data is 32-bit longs
    event.xclient.message_type = wmNetWmState;
    event.xclient.data.l[0] = 1; // Add the state
    event.xclient.data.l[2] = 0; // No secondary property
    event.xclient.data.l[3] = 1; // Sender is a normal application

    event.xclient.data.l[1] = wmStateAbove;
    XSendEvent(contextInfo->display, RootWindow(contextInfo->display, 0), False, SubstructureNotifyMask | SubstructureRedirectMask, &event);

    event.xclient.data.l[1] = wmStateFullScreen;
    XSendEvent(contextInfo->display, RootWindow(contextInfo->display, 0), False, SubstructureNotifyMask | SubstructureRedirectMask, &event);

//    // Set active window
//    Atom wmActiveWindow = XInternAtom(contextInfo->display, "_NET_WM_ACTIVE_WINDOW", 1);

//    event.xclient.message_type = wmActiveWindow;
//    event.xclient.data.l[0] = 1; // Sender is a normal application
//    event.xclient.data.l[1] = 0; // We don't really know the timestamp

//    XSendEvent(contextInfo->display, RootWindow(contextInfo->display, 0), False, SubstructureNotifyMask | SubstructureRedirectMask, &event);


    // Set swap interval to 1 for vsync
    const char *glx_extensions = glXQueryExtensionsString(contextInfo->display, 0);
    if (strstr(glx_extensions, "GLX_SGI_swap_control")) {
        PFNGLXSWAPINTERVALSGIPROC SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalSGI");
        SwapIntervalSGI(1);
    } else if (strstr(glx_extensions, "GLX_EXT_swap_control")) {
        PFNGLXSWAPINTERVALEXTPROC SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");
        SwapIntervalEXT(contextInfo->display, contextInfo->window, 1);
    } else {
        std::cerr << "OpenGLContext Error: Could not access swap interval extension!" << std::endl;
    }

    // Raise window (necessary)
    XMapRaised(contextInfo->display, contextInfo->window);

    XFlush(contextInfo->display);

    // Adjust gamma to one
//    setGamma(1.9);
}

void OpenGLContext::setGamma(float gamma){
    // Adjust gamma
    XF86VidModeGamma xf86Gamma = {gamma, gamma, gamma};
    XF86VidModeSetGamma(contextInfo->display, screenNum, &xf86Gamma);
}

void OpenGLContext::makeContextCurrent(){
    glXMakeCurrent(contextInfo->display, contextInfo->window, contextInfo->context);
}

void OpenGLContext::flush(){

    // Swap buffers
    glXSwapBuffers(contextInfo->display, contextInfo->window);

    // Synchronize CPU with vsync buffer swap
    //glFinish();
    //glXWaitGL();
}

OpenGLContext::~OpenGLContext(){
    std::cout<<"Releasing OpenGL Context\n"<<std::flush;
    if(contextInfo->context){
        // Release context (None, NULL)
        if(!glXMakeCurrent(contextInfo->display, None, NULL))
            std::cerr << "Error. Could not release drawing OpenGLContext." << std::endl;

        glXDestroyContext(contextInfo->display, contextInfo->context);
        XCloseDisplay(contextInfo->display);
        delete contextInfo;
    }
}