| // stb_wingraph.h v0.01 - public domain windows graphics programming |
| // wraps WinMain, ChoosePixelFormat, ChangeDisplayResolution, etc. for |
| // doing OpenGL graphics |
| // |
| // in ONE source file, put '#define STB_DEFINE' before including this |
| // OR put '#define STB_WINMAIN' to define a WinMain that calls stbwingraph_main(void) |
| // |
| // @TODO: |
| // 2d rendering interface (that can be done easily in software) |
| // STB_WINGRAPH_SOFTWARE -- 2d software rendering only |
| // STB_WINGRAPH_OPENGL -- OpenGL only |
| |
| |
| #ifndef INCLUDE_STB_WINGRAPH_H |
| #define INCLUDE_STB_WINGRAPH_H |
| |
| #ifdef STB_WINMAIN |
| #ifndef STB_DEFINE |
| #define STB_DEFINE |
| #define STB_WINGRAPH_DISABLE_DEFINE_AT_END |
| #endif |
| #endif |
| |
| #ifdef STB_DEFINE |
| #pragma comment(lib, "opengl32.lib") |
| #pragma comment(lib, "glu32.lib") |
| #pragma comment(lib, "winmm.lib") |
| #pragma comment(lib, "gdi32.lib") |
| #pragma comment(lib, "user32.lib") |
| #endif |
| |
| #ifdef __cplusplus |
| #define STB_EXTERN extern "C" |
| #else |
| #define STB_EXTERN |
| #endif |
| |
| #ifdef STB_DEFINE |
| #ifndef _WINDOWS_ |
| #ifdef APIENTRY |
| #undef APIENTRY |
| #endif |
| #ifdef WINGDIAPI |
| #undef WINGDIAPI |
| #endif |
| #define _WIN32_WINNT 0x0400 // WM_MOUSEWHEEL |
| #include <windows.h> |
| #endif |
| #include <stdio.h> |
| #include <math.h> |
| #include <time.h> |
| #include <string.h> |
| #include <assert.h> |
| #endif |
| |
| typedef void * stbwingraph_hwnd; |
| typedef void * stbwingraph_hinstance; |
| |
| enum |
| { |
| STBWINGRAPH_unprocessed = -(1 << 24), |
| STBWINGRAPH_do_not_show, |
| STBWINGRAPH_winproc_exit, |
| STBWINGRAPH_winproc_update, |
| STBWINGRAPH_update_exit, |
| STBWINGRAPH_update_pause, |
| }; |
| |
| typedef enum |
| { |
| STBWGE__none=0, |
| |
| STBWGE_create, |
| STBWGE_create_postshow, |
| STBWGE_draw, |
| STBWGE_destroy, |
| STBWGE_char, |
| STBWGE_keydown, |
| STBWGE_syskeydown, |
| STBWGE_keyup, |
| STBWGE_syskeyup, |
| STBWGE_deactivate, |
| STBWGE_activate, |
| STBWGE_size, |
| |
| STBWGE_mousemove , |
| STBWGE_leftdown , STBWGE_leftup , |
| STBWGE_middledown, STBWGE_middleup, |
| STBWGE_rightdown , STBWGE_rightup , |
| STBWGE_mousewheel, |
| } stbwingraph_event_type; |
| |
| typedef struct |
| { |
| stbwingraph_event_type type; |
| |
| // for input events (mouse, keyboard) |
| int mx,my; // mouse x & y |
| int dx,dy; |
| int shift, ctrl, alt; |
| |
| // for keyboard events |
| int key; |
| |
| // for STBWGE_size: |
| int width, height; |
| |
| // for STBWGE_crate |
| int did_share_lists; // if true, wglShareLists succeeded |
| |
| void *handle; |
| |
| } stbwingraph_event; |
| |
| typedef int (*stbwingraph_window_proc)(void *data, stbwingraph_event *event); |
| |
| extern stbwingraph_hinstance stbwingraph_app; |
| extern stbwingraph_hwnd stbwingraph_primary_window; |
| extern int stbwingraph_request_fullscreen; |
| extern int stbwingraph_request_windowed; |
| |
| STB_EXTERN void stbwingraph_ods(char *str, ...); |
| STB_EXTERN int stbwingraph_MessageBox(stbwingraph_hwnd win, unsigned int type, |
| char *caption, char *text, ...); |
| STB_EXTERN int stbwingraph_ChangeResolution(unsigned int w, unsigned int h, |
| unsigned int bits, int use_message_box); |
| STB_EXTERN int stbwingraph_SetPixelFormat(stbwingraph_hwnd win, int color_bits, |
| int alpha_bits, int depth_bits, int stencil_bits, int accum_bits); |
| STB_EXTERN int stbwingraph_DefineClass(void *hinstance, char *iconname); |
| STB_EXTERN void stbwingraph_SwapBuffers(void *win); |
| STB_EXTERN void stbwingraph_Priority(int n); |
| |
| STB_EXTERN void stbwingraph_MakeFonts(void *window, int font_base); |
| STB_EXTERN void stbwingraph_ShowWindow(void *window); |
| STB_EXTERN void *stbwingraph_CreateWindow(int primary, stbwingraph_window_proc func, void *data, char *text, int width, int height, int fullscreen, int resizeable, int dest_alpha, int stencil); |
| STB_EXTERN void *stbwingraph_CreateWindowSimple(stbwingraph_window_proc func, int width, int height); |
| STB_EXTERN void *stbwingraph_CreateWindowSimpleFull(stbwingraph_window_proc func, int fullscreen, int ww, int wh, int fw, int fh); |
| STB_EXTERN void stbwingraph_DestroyWindow(void *window); |
| STB_EXTERN void stbwingraph_ShowCursor(void *window, int visible); |
| STB_EXTERN float stbwingraph_GetTimestep(float minimum_time); |
| STB_EXTERN void stbwingraph_SetGLWindow(void *win); |
| typedef int (*stbwingraph_update)(float timestep, int real, int in_client); |
| STB_EXTERN int stbwingraph_MainLoop(stbwingraph_update func, float mintime); |
| |
| #ifdef STB_DEFINE |
| stbwingraph_hinstance stbwingraph_app; |
| stbwingraph_hwnd stbwingraph_primary_window; |
| int stbwingraph_request_fullscreen; |
| int stbwingraph_request_windowed; |
| |
| void stbwingraph_ods(char *str, ...) |
| { |
| char buffer[1024]; |
| va_list v; |
| va_start(v,str); |
| vsprintf(buffer, str, v); |
| va_end(v); |
| OutputDebugString(buffer); |
| } |
| |
| int stbwingraph_MessageBox(stbwingraph_hwnd win, unsigned int type, char *caption, char *text, ...) |
| { |
| va_list v; |
| char buffer[1024]; |
| va_start(v, text); |
| vsprintf(buffer, text, v); |
| va_end(v); |
| return MessageBox(win, buffer, caption, type); |
| } |
| |
| void stbwingraph_Priority(int n) |
| { |
| int p; |
| switch (n) { |
| case -1: p = THREAD_PRIORITY_BELOW_NORMAL; break; |
| case 0: p = THREAD_PRIORITY_NORMAL; break; |
| case 1: p = THREAD_PRIORITY_ABOVE_NORMAL; break; |
| default: |
| if (n < 0) p = THREAD_PRIORITY_LOWEST; |
| else p = THREAD_PRIORITY_HIGHEST; |
| } |
| SetThreadPriority(GetCurrentThread(), p); |
| } |
| |
| static void stbwingraph_ResetResolution(void) |
| { |
| ChangeDisplaySettings(NULL, 0); |
| } |
| |
| static void stbwingraph_RegisterResetResolution(void) |
| { |
| static int done=0; |
| if (!done) { |
| done = 1; |
| atexit(stbwingraph_ResetResolution); |
| } |
| } |
| |
| int stbwingraph_ChangeResolution(unsigned int w, unsigned int h, unsigned int bits, int use_message_box) |
| { |
| DEVMODE mode; |
| int res; |
| |
| int i, tries=0; |
| for (i=0; ; ++i) { |
| int success = EnumDisplaySettings(NULL, i, &mode); |
| if (!success) break; |
| if (mode.dmBitsPerPel == bits && mode.dmPelsWidth == w && mode.dmPelsHeight == h) { |
| ++tries; |
| success = ChangeDisplaySettings(&mode, CDS_FULLSCREEN); |
| if (success == DISP_CHANGE_SUCCESSFUL) { |
| stbwingraph_RegisterResetResolution(); |
| return TRUE; |
| } |
| break; |
| } |
| } |
| |
| if (!tries) { |
| if (use_message_box) |
| stbwingraph_MessageBox(stbwingraph_primary_window, MB_ICONERROR, NULL, "The resolution %d x %d x %d-bits is not supported.", w, h, bits); |
| return FALSE; |
| } |
| |
| // we tried but failed, so try explicitly doing it without specifying refresh rate |
| |
| // Win95 support logic |
| mode.dmBitsPerPel = bits; |
| mode.dmPelsWidth = w; |
| mode.dmPelsHeight = h; |
| mode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; |
| |
| res = ChangeDisplaySettings(&mode, CDS_FULLSCREEN); |
| |
| switch (res) { |
| case DISP_CHANGE_SUCCESSFUL: |
| stbwingraph_RegisterResetResolution(); |
| return TRUE; |
| |
| case DISP_CHANGE_RESTART: |
| if (use_message_box) |
| stbwingraph_MessageBox(stbwingraph_primary_window, MB_ICONERROR, NULL, "Please set your desktop to %d-bit color and then try again."); |
| return FALSE; |
| |
| case DISP_CHANGE_FAILED: |
| if (use_message_box) |
| stbwingraph_MessageBox(stbwingraph_primary_window, MB_ICONERROR, NULL, "The hardware failed to change modes."); |
| return FALSE; |
| |
| case DISP_CHANGE_BADMODE: |
| if (use_message_box) |
| stbwingraph_MessageBox(stbwingraph_primary_window, MB_ICONERROR, NULL, "The resolution %d x %d x %d-bits is not supported.", w, h, bits); |
| return FALSE; |
| |
| default: |
| if (use_message_box) |
| stbwingraph_MessageBox(stbwingraph_primary_window, MB_ICONERROR, NULL, "An unknown error prevented a change to a %d x %d x %d-bit display.", w, h, bits); |
| return FALSE; |
| } |
| } |
| |
| int stbwingraph_SetPixelFormat(stbwingraph_hwnd win, int color_bits, int alpha_bits, int depth_bits, int stencil_bits, int accum_bits) |
| { |
| HDC dc = GetDC(win); |
| PIXELFORMATDESCRIPTOR pfd = { sizeof(pfd) }; |
| int pixel_format; |
| |
| pfd.nVersion = 1; |
| pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER; |
| pfd.dwLayerMask = PFD_MAIN_PLANE; |
| pfd.iPixelType = PFD_TYPE_RGBA; |
| pfd.cColorBits = color_bits; |
| pfd.cAlphaBits = alpha_bits; |
| pfd.cDepthBits = depth_bits; |
| pfd.cStencilBits = stencil_bits; |
| pfd.cAccumBits = accum_bits; |
| |
| pixel_format = ChoosePixelFormat(dc, &pfd); |
| if (!pixel_format) return FALSE; |
| |
| if (!DescribePixelFormat(dc, pixel_format, sizeof(PIXELFORMATDESCRIPTOR), &pfd)) |
| return FALSE; |
| SetPixelFormat(dc, pixel_format, &pfd); |
| |
| return TRUE; |
| } |
| |
| typedef struct |
| { |
| // app data |
| stbwingraph_window_proc func; |
| void *data; |
| // creation parameters |
| int color, alpha, depth, stencil, accum; |
| HWND share_window; |
| HWND window; |
| // internal data |
| HGLRC rc; |
| HDC dc; |
| int hide_mouse; |
| int in_client; |
| int active; |
| int did_share_lists; |
| int mx,my; // last mouse positions |
| } stbwingraph__window; |
| |
| static void stbwingraph__inclient(stbwingraph__window *win, int state) |
| { |
| if (state != win->in_client) { |
| win->in_client = state; |
| if (win->hide_mouse) |
| ShowCursor(!state); |
| } |
| } |
| |
| static void stbwingraph__key(stbwingraph_event *e, int type, int key, stbwingraph__window *z) |
| { |
| e->type = type; |
| e->key = key; |
| e->shift = (GetKeyState(VK_SHIFT) < 0); |
| e->ctrl = (GetKeyState(VK_CONTROL) < 0); |
| e->alt = (GetKeyState(VK_MENU) < 0); |
| if (z) { |
| e->mx = z->mx; |
| e->my = z->my; |
| } else { |
| e->mx = e->my = 0; |
| } |
| e->dx = e->dy = 0; |
| } |
| |
| static void stbwingraph__mouse(stbwingraph_event *e, int type, WPARAM wparam, LPARAM lparam, int capture, void *wnd, stbwingraph__window *z) |
| { |
| static int captured = 0; |
| e->type = type; |
| e->mx = (short) LOWORD(lparam); |
| e->my = (short) HIWORD(lparam); |
| if (!z || z->mx == -(1 << 30)) { |
| e->dx = e->dy = 0; |
| } else { |
| e->dx = e->mx - z->mx; |
| e->dy = e->my - z->my; |
| } |
| e->shift = (wparam & MK_SHIFT) != 0; |
| e->ctrl = (wparam & MK_CONTROL) != 0; |
| e->alt = (wparam & MK_ALT) != 0; |
| if (z) { |
| z->mx = e->mx; |
| z->my = e->my; |
| } |
| if (capture) { |
| if (!captured && capture == 1) |
| SetCapture(wnd); |
| captured += capture; |
| if (!captured && capture == -1) |
| ReleaseCapture(); |
| if (captured < 0) captured = 0; |
| } |
| } |
| |
| static void stbwingraph__mousewheel(stbwingraph_event *e, int type, WPARAM wparam, LPARAM lparam, int capture, void *wnd, stbwingraph__window *z) |
| { |
| // lparam seems bogus! |
| static int captured = 0; |
| e->type = type; |
| if (z) { |
| e->mx = z->mx; |
| e->my = z->my; |
| } |
| e->dx = e->dy = 0; |
| e->shift = (wparam & MK_SHIFT) != 0; |
| e->ctrl = (wparam & MK_CONTROL) != 0; |
| e->alt = (GetKeyState(VK_MENU) < 0); |
| e->key = ((int) wparam >> 16); |
| } |
| |
| int stbwingraph_force_update; |
| static int WINAPI stbwingraph_WinProc(HWND wnd, UINT msg, WPARAM wparam, LPARAM lparam) |
| { |
| int allow_default = TRUE; |
| stbwingraph_event e = { STBWGE__none }; |
| // the following line is wrong for 64-bit windows, but VC6 doesn't have GetWindowLongPtr |
| stbwingraph__window *z = (stbwingraph__window *) GetWindowLong(wnd, GWL_USERDATA); |
| |
| switch (msg) { |
| |
| case WM_CREATE: |
| { |
| LPCREATESTRUCT lpcs = (LPCREATESTRUCT) lparam; |
| assert(z == NULL); |
| z = (stbwingraph__window *) lpcs->lpCreateParams; |
| SetWindowLong(wnd, GWL_USERDATA, (LONG) z); |
| z->dc = GetDC(wnd); |
| if (stbwingraph_SetPixelFormat(wnd, z->color, z->alpha, z->depth, z->stencil, z->accum)) { |
| z->rc = wglCreateContext(z->dc); |
| if (z->rc) { |
| e.type = STBWGE_create; |
| z->did_share_lists = FALSE; |
| if (z->share_window) { |
| stbwingraph__window *y = (stbwingraph__window *) GetWindowLong(z->share_window, GWL_USERDATA); |
| if (wglShareLists(z->rc, y->rc)) |
| z->did_share_lists = TRUE; |
| } |
| wglMakeCurrent(z->dc, z->rc); |
| return 0; |
| } |
| } |
| return -1; |
| } |
| |
| case WM_PAINT: { |
| PAINTSTRUCT ps; |
| HDC hdc = BeginPaint(wnd, &ps); |
| SelectObject(hdc, GetStockObject(NULL_BRUSH)); |
| e.type = STBWGE_draw; |
| e.handle = wnd; |
| z->func(z->data, &e); |
| EndPaint(wnd, &ps); |
| return 0; |
| } |
| |
| case WM_DESTROY: |
| e.type = STBWGE_destroy; |
| e.handle = wnd; |
| if (z && z->func) |
| z->func(z->data, &e); |
| wglMakeCurrent(NULL, NULL) ; |
| if (z) { |
| if (z->rc) wglDeleteContext(z->rc); |
| z->dc = 0; |
| z->rc = 0; |
| } |
| if (wnd == stbwingraph_primary_window) |
| PostQuitMessage (0); |
| return 0; |
| |
| case WM_CHAR: stbwingraph__key(&e, STBWGE_char , wparam, z); break; |
| case WM_KEYDOWN: stbwingraph__key(&e, STBWGE_keydown, wparam, z); break; |
| case WM_KEYUP: stbwingraph__key(&e, STBWGE_keyup , wparam, z); break; |
| |
| case WM_NCMOUSEMOVE: stbwingraph__inclient(z,0); break; |
| case WM_MOUSEMOVE: stbwingraph__inclient(z,1); stbwingraph__mouse(&e, STBWGE_mousemove, wparam, lparam,0,wnd, z); break; |
| case WM_LBUTTONDOWN: stbwingraph__mouse(&e, STBWGE_leftdown, wparam, lparam,1,wnd, z); break; |
| case WM_MBUTTONDOWN: stbwingraph__mouse(&e, STBWGE_middledown, wparam, lparam,1,wnd, z); break; |
| case WM_RBUTTONDOWN: stbwingraph__mouse(&e, STBWGE_rightdown, wparam, lparam,1,wnd, z); break; |
| case WM_LBUTTONUP: stbwingraph__mouse(&e, STBWGE_leftup, wparam, lparam,-1,wnd, z); break; |
| case WM_MBUTTONUP: stbwingraph__mouse(&e, STBWGE_middleup, wparam, lparam,-1,wnd, z); break; |
| case WM_RBUTTONUP: stbwingraph__mouse(&e, STBWGE_rightup, wparam, lparam,-1,wnd, z); break; |
| case WM_MOUSEWHEEL: stbwingraph__mousewheel(&e, STBWGE_mousewheel, wparam, lparam,0,wnd, z); break; |
| |
| case WM_ACTIVATE: |
| allow_default = FALSE; |
| if (LOWORD(wparam)==WA_INACTIVE ) { |
| wglMakeCurrent(z->dc, NULL); |
| e.type = STBWGE_deactivate; |
| z->active = FALSE; |
| } else { |
| wglMakeCurrent(z->dc, z->rc); |
| e.type = STBWGE_activate; |
| z->active = TRUE; |
| } |
| e.handle = wnd; |
| z->func(z->data, &e); |
| return 0; |
| |
| case WM_SIZE: { |
| RECT rect; |
| allow_default = FALSE; |
| GetClientRect(wnd, &rect); |
| e.type = STBWGE_size; |
| e.width = rect.right; |
| e.height = rect.bottom; |
| e.handle = wnd; |
| z->func(z->data, &e); |
| return 0; |
| } |
| |
| default: |
| return DefWindowProc (wnd, msg, wparam, lparam); |
| } |
| |
| if (e.type != STBWGE__none) { |
| int n; |
| e.handle = wnd; |
| n = z->func(z->data, &e); |
| if (n == STBWINGRAPH_winproc_exit) { |
| PostQuitMessage(0); |
| n = 0; |
| } |
| if (n == STBWINGRAPH_winproc_update) { |
| stbwingraph_force_update = TRUE; |
| return 1; |
| } |
| if (n != STBWINGRAPH_unprocessed) |
| return n; |
| } |
| return DefWindowProc (wnd, msg, wparam, lparam); |
| } |
| |
| int stbwingraph_DefineClass(HINSTANCE hInstance, char *iconname) |
| { |
| WNDCLASSEX wndclass; |
| |
| stbwingraph_app = hInstance; |
| |
| wndclass.cbSize = sizeof(wndclass); |
| wndclass.style = CS_OWNDC; |
| wndclass.lpfnWndProc = (WNDPROC) stbwingraph_WinProc; |
| wndclass.cbClsExtra = 0; |
| wndclass.cbWndExtra = 0; |
| wndclass.hInstance = hInstance; |
| wndclass.hIcon = LoadIcon(hInstance, iconname); |
| wndclass.hCursor = LoadCursor(NULL,IDC_ARROW); |
| wndclass.hbrBackground = GetStockObject(NULL_BRUSH); |
| wndclass.lpszMenuName = "zwingraph"; |
| wndclass.lpszClassName = "zwingraph"; |
| wndclass.hIconSm = NULL; |
| |
| if (!RegisterClassEx(&wndclass)) |
| return FALSE; |
| return TRUE; |
| } |
| |
| void stbwingraph_ShowWindow(void *window) |
| { |
| stbwingraph_event e = { STBWGE_create_postshow }; |
| stbwingraph__window *z = (stbwingraph__window *) GetWindowLong(window, GWL_USERDATA); |
| ShowWindow(window, SW_SHOWNORMAL); |
| InvalidateRect(window, NULL, TRUE); |
| UpdateWindow(window); |
| e.handle = window; |
| z->func(z->data, &e); |
| } |
| |
| void *stbwingraph_CreateWindow(int primary, stbwingraph_window_proc func, void *data, char *text, |
| int width, int height, int fullscreen, int resizeable, int dest_alpha, int stencil) |
| { |
| HWND win; |
| DWORD dwstyle; |
| stbwingraph__window *z = (stbwingraph__window *) malloc(sizeof(*z)); |
| |
| if (z == NULL) return NULL; |
| memset(z, 0, sizeof(*z)); |
| z->color = 24; |
| z->depth = 24; |
| z->alpha = dest_alpha; |
| z->stencil = stencil; |
| z->func = func; |
| z->data = data; |
| z->mx = -(1 << 30); |
| z->my = 0; |
| |
| if (primary) { |
| if (stbwingraph_request_windowed) |
| fullscreen = FALSE; |
| else if (stbwingraph_request_fullscreen) |
| fullscreen = TRUE; |
| } |
| |
| if (fullscreen) { |
| #ifdef STB_SIMPLE |
| stbwingraph_ChangeResolution(width, height, 32, 1); |
| #else |
| if (!stbwingraph_ChangeResolution(width, height, 32, 0)) |
| return NULL; |
| #endif |
| dwstyle = WS_POPUP | WS_CLIPSIBLINGS; |
| } else { |
| RECT rect; |
| dwstyle = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX; |
| if (resizeable) |
| dwstyle |= WS_SIZEBOX | WS_MAXIMIZEBOX; |
| rect.top = 0; |
| rect.left = 0; |
| rect.right = width; |
| rect.bottom = height; |
| AdjustWindowRect(&rect, dwstyle, FALSE); |
| width = rect.right - rect.left; |
| height = rect.bottom - rect.top; |
| } |
| |
| win = CreateWindow("zwingraph", text ? text : "sample", dwstyle, |
| CW_USEDEFAULT,0, width, height, |
| NULL, NULL, stbwingraph_app, z); |
| |
| if (win == NULL) return win; |
| |
| if (primary) { |
| if (stbwingraph_primary_window) |
| stbwingraph_DestroyWindow(stbwingraph_primary_window); |
| stbwingraph_primary_window = win; |
| } |
| |
| { |
| stbwingraph_event e = { STBWGE_create }; |
| stbwingraph__window *z = (stbwingraph__window *) GetWindowLong(win, GWL_USERDATA); |
| z->window = win; |
| e.did_share_lists = z->did_share_lists; |
| e.handle = win; |
| if (z->func(z->data, &e) != STBWINGRAPH_do_not_show) |
| stbwingraph_ShowWindow(win); |
| } |
| |
| return win; |
| } |
| |
| void *stbwingraph_CreateWindowSimple(stbwingraph_window_proc func, int width, int height) |
| { |
| int fullscreen = 0; |
| #ifndef _DEBUG |
| if (width == 640 && height == 480) fullscreen = 1; |
| if (width == 800 && height == 600) fullscreen = 1; |
| if (width == 1024 && height == 768) fullscreen = 1; |
| if (width == 1280 && height == 1024) fullscreen = 1; |
| if (width == 1600 && height == 1200) fullscreen = 1; |
| //@TODO: widescreen widths |
| #endif |
| return stbwingraph_CreateWindow(1, func, NULL, NULL, width, height, fullscreen, 1, 0, 0); |
| } |
| |
| void *stbwingraph_CreateWindowSimpleFull(stbwingraph_window_proc func, int fullscreen, int ww, int wh, int fw, int fh) |
| { |
| if (fullscreen == -1) { |
| #ifdef _DEBUG |
| fullscreen = 0; |
| #else |
| fullscreen = 1; |
| #endif |
| } |
| |
| if (fullscreen) { |
| if (fw) ww = fw; |
| if (fh) wh = fh; |
| } |
| return stbwingraph_CreateWindow(1, func, NULL, NULL, ww, wh, fullscreen, 1, 0, 0); |
| } |
| |
| void stbwingraph_DestroyWindow(void *window) |
| { |
| stbwingraph__window *z = (stbwingraph__window *) GetWindowLong(window, GWL_USERDATA); |
| DestroyWindow(window); |
| free(z); |
| if (stbwingraph_primary_window == window) |
| stbwingraph_primary_window = NULL; |
| } |
| |
| void stbwingraph_ShowCursor(void *window, int visible) |
| { |
| int hide; |
| stbwingraph__window *win; |
| if (!window) |
| window = stbwingraph_primary_window; |
| win = (stbwingraph__window *) GetWindowLong((HWND) window, GWL_USERDATA); |
| hide = !visible; |
| if (hide != win->hide_mouse) { |
| win->hide_mouse = hide; |
| if (!hide) |
| ShowCursor(TRUE); |
| else if (win->in_client) |
| ShowCursor(FALSE); |
| } |
| } |
| |
| float stbwingraph_GetTimestep(float minimum_time) |
| { |
| float elapsedTime; |
| double thisTime; |
| static double lastTime = -1; |
| |
| if (lastTime == -1) |
| lastTime = timeGetTime() / 1000.0 - minimum_time; |
| |
| for(;;) { |
| thisTime = timeGetTime() / 1000.0; |
| elapsedTime = (float) (thisTime - lastTime); |
| if (elapsedTime >= minimum_time) { |
| lastTime = thisTime; |
| return elapsedTime; |
| } |
| #if 1 |
| Sleep(2); |
| #endif |
| } |
| } |
| |
| void stbwingraph_SetGLWindow(void *win) |
| { |
| stbwingraph__window *z = (stbwingraph__window *) GetWindowLong(win, GWL_USERDATA); |
| if (z) |
| wglMakeCurrent(z->dc, z->rc); |
| } |
| |
| void stbwingraph_MakeFonts(void *window, int font_base) |
| { |
| wglUseFontBitmaps(GetDC(window ? window : stbwingraph_primary_window), 0, 256, font_base); |
| } |
| |
| // returns 1 if WM_QUIT, 0 if 'func' returned 0 |
| int stbwingraph_MainLoop(stbwingraph_update func, float mintime) |
| { |
| int needs_drawing = FALSE; |
| MSG msg; |
| |
| int is_animating = TRUE; |
| if (mintime <= 0) mintime = 0.01f; |
| |
| for(;;) { |
| int n; |
| |
| is_animating = TRUE; |
| // wait for a message if: (a) we're animating and there's already a message |
| // or (b) we're not animating |
| if (!is_animating || PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) { |
| stbwingraph_force_update = FALSE; |
| if (GetMessage(&msg, NULL, 0, 0)) { |
| TranslateMessage(&msg); |
| DispatchMessage(&msg); |
| } else { |
| return 1; // WM_QUIT |
| } |
| |
| // only force a draw for certain messages... |
| // if I don't do this, we peg at 50% for some reason... must |
| // be a bug somewhere, because we peg at 100% when rendering... |
| // very weird... looks like NVIDIA is pumping some messages |
| // through our pipeline? well, ok, I guess if we can get |
| // non-user-generated messages we have to do this |
| if (!stbwingraph_force_update) { |
| switch (msg.message) { |
| case WM_MOUSEMOVE: |
| case WM_NCMOUSEMOVE: |
| break; |
| case WM_CHAR: |
| case WM_KEYDOWN: |
| case WM_KEYUP: |
| case WM_LBUTTONDOWN: |
| case WM_MBUTTONDOWN: |
| case WM_RBUTTONDOWN: |
| case WM_LBUTTONUP: |
| case WM_MBUTTONUP: |
| case WM_RBUTTONUP: |
| case WM_TIMER: |
| case WM_SIZE: |
| case WM_ACTIVATE: |
| needs_drawing = TRUE; |
| break; |
| } |
| } else |
| needs_drawing = TRUE; |
| } |
| |
| // if another message, process that first |
| // @TODO: i don't think this is working, because I can't key ahead |
| // in the SVT demo app |
| if (PeekMessage(&msg, NULL, 0,0, PM_NOREMOVE)) |
| continue; |
| |
| // and now call update |
| if (needs_drawing || is_animating) { |
| int real=1, in_client=1; |
| if (stbwingraph_primary_window) { |
| stbwingraph__window *z = (stbwingraph__window *) GetWindowLong(stbwingraph_primary_window, GWL_USERDATA); |
| if (z && !z->active) { |
| real = 0; |
| } |
| if (z) |
| in_client = z->in_client; |
| } |
| |
| if (stbwingraph_primary_window) |
| stbwingraph_SetGLWindow(stbwingraph_primary_window); |
| n = func(stbwingraph_GetTimestep(mintime), real, in_client); |
| if (n == STBWINGRAPH_update_exit) |
| return 0; // update_quit |
| |
| is_animating = (n != STBWINGRAPH_update_pause); |
| |
| needs_drawing = FALSE; |
| } |
| } |
| } |
| |
| void stbwingraph_SwapBuffers(void *win) |
| { |
| stbwingraph__window *z; |
| if (win == NULL) win = stbwingraph_primary_window; |
| z = (stbwingraph__window *) GetWindowLong(win, GWL_USERDATA); |
| if (z && z->dc) |
| SwapBuffers(z->dc); |
| } |
| #endif |
| |
| #ifdef STB_WINMAIN |
| void stbwingraph_main(void); |
| |
| char *stb_wingraph_commandline; |
| |
| int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) |
| { |
| { |
| char buffer[1024]; |
| // add spaces to either side of the string |
| buffer[0] = ' '; |
| strcpy(buffer+1, lpCmdLine); |
| strcat(buffer, " "); |
| if (strstr(buffer, " -reset ")) { |
| ChangeDisplaySettings(NULL, 0); |
| exit(0); |
| } |
| if (strstr(buffer, " -window ") || strstr(buffer, " -windowed ")) |
| stbwingraph_request_windowed = TRUE; |
| else if (strstr(buffer, " -full ") || strstr(buffer, " -fullscreen ")) |
| stbwingraph_request_fullscreen = TRUE; |
| } |
| stb_wingraph_commandline = lpCmdLine; |
| |
| stbwingraph_DefineClass(hInstance, "appicon"); |
| stbwingraph_main(); |
| |
| return 0; |
| } |
| #endif |
| |
| #undef STB_EXTERN |
| #ifdef STB_WINGRAPH_DISABLE_DEFINE_AT_END |
| #undef STB_DEFINE |
| #endif |
| |
| #endif // INCLUDE_STB_WINGRAPH_H |
