Subversion Repositories seema-scanner

#include "OpenGLContext.h"

#include <windows.h>

#include <winuser.h>

#include <tchar.h>

#include <ShObjIdl.h>

#include <GL/gl.h>

#include <stdio.h>

BOOL CALLBACK monitorEnumerator(HMONITOR hMonitor, HDC, LPRECT, LPARAM dwData){

    MONITORINFOEX monitorInfo;

    ZeroMemory(&monitorInfo, sizeof(MONITORINFOEX));

    monitorInfo.cbSize = sizeof(MONITORINFOEX);

    GetMonitorInfo(hMonitor, &monitorInfo);

    ScreenInfo screen;

    char deviceName[32];

    wcstombs((char *)deviceName, (wchar_t*)monitorInfo.szDevice, 32);

    screen.name = std::string(deviceName);

    RECT rect = monitorInfo.rcMonitor;

    screen.resX = rect.right - rect.left;

    screen.resY = rect.bottom - rect.top;

    screen.posX = rect.left;

    screen.posY = rect.top;

    std::vector<ScreenInfo> *ret = reinterpret_cast<std::vector<ScreenInfo>*>(dwData);

    ret->push_back(screen);

    return true;

}

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

    std::vector<ScreenInfo> ret;

    EnumDisplayMonitors(NULL, NULL, monitorEnumerator, (LPARAM)&ret);

//    DISPLAY_DEVICE dd;

//    ZeroMemory(&dd, sizeof(DISPLAY_DEVICE));

//    dd.cb = sizeof(dd);

//    for(int i=0; EnumDisplayDevices(NULL, i, &dd, 0); i++){

//        if ((dd.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) || !(dd.StateFlags & DISPLAY_DEVICE_ACTIVE))

//            continue;

//        // Get additional info

//        DISPLAY_DEVICE display;

//        ZeroMemory(&display, sizeof(DISPLAY_DEVICE));

//        display.cb = sizeof(DISPLAY_DEVICE);

//        EnumDisplayDevices(dd.DeviceName, 0, &display, 0);

//        HDC dc = CreateDC(L"DISPLAY", display.DeviceString, NULL, NULL);

//        ScreenInfo screen;

//        char deviceName[32];

//        wcstombs(deviceName, display.DeviceName, 32);

//        screen.name = std::string(deviceName);

//        screen.resX = GetDeviceCaps(dc, HORZRES);

//        screen.resY = GetDeviceCaps(dc, VERTRES);

//        ret.push_back(screen);

//        DEVMODE settings;

//        ZeroMemory(&settings, sizeof(DEVMODE));

//        settings.dmSize = sizeof(DEVMODE);

//        EnumDisplaySettings(display.DeviceName, ENUM_CURRENT_SETTINGS, &settings);

//        int xpos = settings.dmPosition.x;

//        int ypos = settings.dmPosition.y;

//        DeleteDC(dc);

//    }

    return ret;

}

// Window Function

LONG WINAPI MainWndProc (

    HWND    hWnd,

    UINT    uMsg,

    WPARAM  wParam,

    LPARAM  lParam)

{

    LONG lRet = 1;

    PAINTSTRUCT ps;

    switch (uMsg) {

    case WM_PAINT:

        BeginPaint(hWnd, &ps);

        EndPaint(hWnd, &ps);

        break;

    default:

        lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);

        break;

    }

    return lRet;

}

struct OpenGLContext::OpenGLContextInfo{

    HDC hdc;     // device OpenGLContext handle

    HGLRC hglrc; // OpenGL rendering OpenGLContext

    HWND hwnd;	 // window handle

    HINSTANCE hinstance; // application instance handle

    OpenGLContextInfo() : hdc(NULL), hglrc(NULL), hwnd(NULL){}

};

OpenGLContext::OpenGLContext(unsigned int _screenNum) : screenNum(_screenNum){

    std::vector<ScreenInfo> screenInfo = OpenGLContext::GetScreenInfo();

    screenResX = screenInfo[screenNum].resX;

    screenResY = screenInfo[screenNum].resY;

    // New object for OpenGLContext information

    contextInfo = new OpenGLContextInfo();

    // Create and register window class

    WNDCLASS wndclass;

    wndclass.style = CS_VREDRAW;

    wndclass.lpfnWndProc = (WNDPROC)MainWndProc;

    wndclass.cbClsExtra = 0;

    wndclass.cbWndExtra = 0;

    wndclass.hInstance = contextInfo->hinstance;

    wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);

    wndclass.hCursor = LoadCursor(NULL, IDC_NO);

    wndclass.hbrBackground = NULL;

    wndclass.lpszMenuName = NULL;

    wndclass.lpszClassName = L"ProjectorGLClass";

    RegisterClass(&wndclass);

    // create the fullscreen window

    contextInfo->hwnd = CreateWindowEx(WS_EX_TOPMOST,L"ProjectorGLClass", L"Projector",

                                     WS_POPUP|WS_CLIPCHILDREN,

                                     screenInfo[screenNum].posX, screenInfo[screenNum].posY, screenResX, screenResY,

                                     NULL, NULL, contextInfo->hinstance, NULL);

//    contextInfo->hwnd = CreateWindow(L"ProjectorGLClass", L"Projector",

//                                     WS_POPUP|WS_EX_TOOLWINDOW,

//                                     screenInfo[screenNum].posX, screenInfo[screenNum].posY, screenResX, screenResY,

//                                     GetDesktopWindow(), NULL, contextInfo->hinstance, NULL);

    if(!contextInfo->hwnd)

        std::cerr << "Could not create window!" << std::endl;

    //CoTaskbarList list = CoTaskbarList();

    // Get window device OpenGLContext

    if ((contextInfo->hdc = GetDC(contextInfo->hwnd)) == NULL)

        std::cerr << "Could not get window device OpenGLContext!" << std::endl;

    // Select pixel format description

    PIXELFORMATDESCRIPTOR pfd, *ppfd;

    int pixelformat;

    ppfd = &pfd;

    ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);

    ppfd->nVersion = 1;

    ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;

    ppfd->dwLayerMask = PFD_MAIN_PLANE;

    ppfd->iPixelType = PFD_TYPE_COLORINDEX;

    ppfd->cColorBits = 8;

    ppfd->cDepthBits = 16;

    ppfd->cAccumBits = 0;

    ppfd->cStencilBits = 0;

    pixelformat = ChoosePixelFormat(contextInfo->hdc, ppfd);

    if ( (pixelformat = ChoosePixelFormat(contextInfo->hdc, ppfd)) == 0 )

        std::cerr << "Failed to choose pixel format!" << std::endl;

    if (SetPixelFormat(contextInfo->hdc, pixelformat, ppfd) == FALSE)

        std::cerr << "Failed to set pixel format!" << std::endl;

    // Create the OpenGL rendering OpenGLContext

    if ((contextInfo->hglrc = wglCreateContext(contextInfo->hdc)) == NULL)

        std::cerr << "Could not create OpenGL rendering OpenGLContext!" << std::endl;

    // Set swap interval

    //wglSwapIntervalEXT(1);

    // Make OpenGLContext current

    wglMakeCurrent(contextInfo->hdc, contextInfo->hglrc);

    // Show window

    ShowWindow(contextInfo->hwnd, SW_SHOW);

    UpdateWindow(contextInfo->hwnd);

    // Adjust gamma to one

    setGamma(1.0);

}

void OpenGLContext::setGamma(float gamma){

    // Adjust gamma

}

void OpenGLContext::makeContextCurrent(){

    wglMakeCurrent(contextInfo->hdc, contextInfo->hglrc);

}

void OpenGLContext::flush(){

    // Swap buffers

    SwapBuffers(contextInfo->hdc);

    // Synchronize CPU with vsync buffer swap

    glFinish();

}

OpenGLContext::~OpenGLContext(){

    DestroyWindow(contextInfo->hwnd);

    wglMakeCurrent(contextInfo->hdc, NULL);	// release device OpenGLContext in use by rc

    wglDeleteContext(contextInfo->hglrc);	// delete rendering OpenGLContext

    delete contextInfo;

}