osWindows.c

Go to the documentation of this file.

// Summary: Defines methods for windows-specific functions.
// Copyright: 2007  Philip Rideout.  All rights reserved.
// License: see bsd-license.txt

#include <stdio.h>
#include "os.h"
#include "resource.h"
#include <GL/wglext.h>

static HINSTANCE g_hInstance;
static HDC g_hDC;
static OS_Event *g_eventHead = 0;
static OS_Event **g_eventTail = &g_eventHead;
static HWND g_hWnd;
static int g_cursorVisible = 1;

int main(int argc, char** argv);

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    int argc;
    char** argv = (char**) CommandLineToArgvW((LPCWSTR) lpCmdLine, &argc);
    g_hInstance = hInstance;
    return main(argc, argv);
}

void osWaitVsync(int interval)
{
    PFNWGLSWAPINTERVALEXTPROC wglSwapInterval;
    wglSwapInterval = (PFNWGLSWAPINTERVALEXTPROC) wglGetProcAddress("wglSwapIntervalEXT");
    if (wglSwapInterval)
        wglSwapInterval(interval);
}

int osGetScreenWidth() { return GetSystemMetrics(SM_CXSCREEN); }
int osGetScreenHeight() { return GetSystemMetrics(SM_CYSCREEN); }

#pragma warning(push)
#pragma warning(disable:4996)
void fatalf(const char *format, ...)
{
    va_list args;
    int length;
    char *buffer;

    va_start(args, format);
    length = _vscprintf(format, args);
    buffer = malloc(length + 1);
    vsprintf(buffer, format, args);
    OutputDebugString("\n\n");
    OutputDebugString(buffer);
    OutputDebugString("\n\n");
    free(buffer);
    exit(1);
}
void debugf(const char *format, ...)
{
    va_list args;
    int length;
    char *buffer;

    va_start(args, format);
    length = _vscprintf(format, args);
    buffer = malloc(length + 1);
    vsprintf(buffer, format, args);
    OutputDebugString(buffer);
    free(buffer);
}
#pragma warning(pop)

void osQuit(void)
{
    timeEndPeriod(1);

    if (g_hWnd)
    {
        DestroyWindow(g_hWnd);
        g_hWnd = 0;
    }

    while (g_eventHead)
    {
        OS_Event *pending = g_eventHead;
        g_eventHead = pending->next;
        if (!g_eventHead)
            g_eventTail = &g_eventHead;
        free(pending);
    }
}

static LRESULT CALLBACK WinProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    OS_Event e;
    e.type = 0;

    switch (uMsg)
    {
        case WM_KEYDOWN:
            e.type = OS_KEYDOWN;
            e.key.key = (unsigned char) wParam;
            e.key.state = OSKS_DOWN;
            break;

        case WM_KEYUP:
            e.type = OS_KEYUP;
            e.key.key = (unsigned char) wParam;
            e.key.state = OSKS_UP;
            break;

        case WM_SIZE:
            e.type = OS_RESIZE;
            e.resize.width = LOWORD(lParam);
            e.resize.height = HIWORD(lParam);
            break;

        case WM_PAINT:
        case WM_ERASEBKGND:
            break;

        case WM_MOUSEMOVE:
            e.type = OS_MOUSEMOTION;
            e.mouse.button = 0;
            if (wParam & MK_LBUTTON) e.mouse.button |= OS_BUTTON_LEFT;
            if (wParam & MK_MBUTTON) e.mouse.button |= OS_BUTTON_MIDDLE;
            if (wParam & MK_RBUTTON) e.mouse.button |= OS_BUTTON_RIGHT;
            e.mouse.x = LOWORD(lParam);
            e.mouse.y = HIWORD(lParam);
            break;

        case WM_LBUTTONDOWN:
            e.type = OS_MOUSEBUTTONDOWN;
            e.mouse.button = OS_BUTTON_LEFT;
            e.mouse.x = LOWORD(lParam);
            e.mouse.y = HIWORD(lParam);
            break;

        case WM_LBUTTONUP:
            e.type = OS_MOUSEBUTTONUP;
            e.mouse.button = OS_BUTTON_LEFT;
            e.mouse.x = LOWORD(lParam);
            e.mouse.y = HIWORD(lParam);
            break;

        case WM_CLOSE:
        case WM_QUIT:
            e.type = OS_QUIT;
            break;
    }

    if (e.type)
    {
        e.next = 0;
        *g_eventTail = malloc(sizeof(OS_Event));
        memcpy(*g_eventTail, &e, sizeof(OS_Event));
        g_eventTail = &((*g_eventTail)->next);
    }

    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

void osInit(int width, int height, unsigned int flags, int *attribs)
{
    HICON tiny, big;
    PIXELFORMATDESCRIPTOR pfd;
    LPCTSTR name = "Flatland Demo";
    int pixelFormat;
    HGLRC hRC;
    RECT rect;
    DWORD dwStyle, dwExStyle;
    int x, y;

    WNDCLASS wndClass =
    {
        CS_OWNDC, WinProc, 0, 0,
        g_hInstance, 0, LoadCursor(0, IDC_ARROW), 0, 0, name
    };

    atexit(osQuit);
    RegisterClass(&wndClass);

    if (flags & OS_FULLSCREEN)
    {
        width = GetSystemMetrics(SM_CXSCREEN);
        height = GetSystemMetrics(SM_CYSCREEN);
        dwStyle = WS_POPUP | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
        dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE | WS_EX_TOPMOST;
        x = y = 0;
    }
    else
    {
        dwStyle = WS_CAPTION | WS_SYSMENU | WS_VISIBLE | WS_MINIMIZEBOX;
        dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
        x = y = CW_USEDEFAULT;
        if (flags & OS_RESIZABLE)
            dwStyle |= WS_SIZEBOX | WS_MAXIMIZEBOX;
    }

    // Create the window.
    SetRect(&rect, 0, 0, width, height);
    AdjustWindowRectEx(&rect, dwStyle, FALSE, dwExStyle);
    width = rect.right - rect.left;
    height = rect.bottom - rect.top;
    g_hWnd = CreateWindowEx(0, name, name, dwStyle, x, y, width, height, 0, 0, g_hInstance, 0);

    // Create the GL context.
    ZeroMemory(&pfd, sizeof(pfd));
    pfd.nSize = sizeof(pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 0;
    pfd.cStencilBits = 0;
    pfd.iLayerType = PFD_MAIN_PLANE;

    g_hDC = GetDC(g_hWnd);
    pixelFormat = ChoosePixelFormat(g_hDC, &pfd);

    SetPixelFormat(g_hDC, pixelFormat, &pfd);
    hRC = wglCreateContext(g_hDC);
    wglMakeCurrent(g_hDC, hRC);

    tiny = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_SMALL));
    SendMessage(g_hWnd, WM_SETICON, ICON_SMALL, (LPARAM) tiny);

    big = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_BIG));
    SendMessage(g_hWnd, WM_SETICON, ICON_BIG, (LPARAM) big);

    timeBeginPeriod(1);
}

unsigned int osGetMilliseconds()
{
    return timeGetTime();
}

int osPollEvent(OS_Event *e)
{
    MSG msg;
    msg.message = WM_NULL;

    while (PeekMessage(&msg, g_hWnd, 0, 0, PM_REMOVE))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);

        if (msg.message == WM_QUIT || msg.message == WM_CLOSE)
        {
            e->type = OS_QUIT;
            return 1;
        }
    }

    if (g_eventHead)
    {
        OS_Event *pending = g_eventHead;
        memcpy(e, pending, sizeof(OS_Event));
        g_eventHead = pending->next;
        if (!g_eventHead)
            g_eventTail = &g_eventHead;
        free(pending);
        return 1;
    }

    e->type = 0;
    return 0;
}

void osSwapBuffers()
{
    SwapBuffers(g_hDC);
}

int osIsKeyDown(int key)
{
    int vKey;
    switch (key)
    {
        case OSK_ESCAPE: vKey = VK_ESCAPE; break;
        case OSK_LEFT: vKey = VK_LEFT; break;
        case OSK_RIGHT: vKey = VK_RIGHT; break;
        case OSK_UP: vKey = VK_UP; break;
        case OSK_DOWN: vKey = VK_DOWN; break;
        case OSK_SHIFT: vKey = VK_SHIFT; break;
        default: return 0;
    }
    return (GetAsyncKeyState(vKey) & 0x8000) == 0x8000;
}

int osShowCursor(int toggle)
{
    switch (toggle)
    {
        case OS_ENABLE:
            if (!g_cursorVisible)
            {
                ShowCursor(TRUE);
                g_cursorVisible = 1;
            }
            break;

        case OS_DISABLE:
            if (g_cursorVisible)
            {
                ShowCursor(FALSE);
                g_cursorVisible = 0;
            }
            break;

        case OS_QUERY:
            return g_cursorVisible;
    }

    return g_cursorVisible;
}

---