--- /dev/null
+// 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
projects / henge / apc.git / blobdiff