sean-m
/
stb
mirror of https://github.com/nothings/stb.git
1
0
Fork 0
Code Issues Releases Activity
stb/tests/oversample/stb_wingraph.h

830 lines
24 KiB
C
Raw Blame History

// 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
Reference in New Issue View Git Blame Copy Permalink