diff options
Diffstat (limited to 'Editor/wog.c')
| -rw-r--r-- | Editor/wog.c | 746 |
1 files changed, 746 insertions, 0 deletions
diff --git a/Editor/wog.c b/Editor/wog.c new file mode 100644 index 0000000..6cfbf64 --- /dev/null +++ b/Editor/wog.c @@ -0,0 +1,746 @@ +/** +* Copyright (c) 2015~2017 chai(neonum) +* +* This library is free software; you can redistribute it and/or modify it +* under the terms of the MIT license. See LICENSE for details. +*/ + +#include "wog.h" +#include <windows.h> +#include <malloc.h> +#include <stdio.h> +#include <memory.h> +#include <assert.h> + +#if WOG_API == WOG_GL +#include <gl/GL.h> +#include <gl/GLU.h> +#endif + + +#if WOG_API == WOG_GL +/** +* We need opengl32.lib and glu32.lib for using opengl functions on +* windows platform. +*/ +#pragma comment( lib, "opengl32.lib" ) +//#pragma comment( lib, "glu32.lib" ) +#endif + +#define WINDOW_CLASS "WOG_WND" + +#define heap_alloc(T, C) (T*)malloc(sizeof(T)*(C)) +#define stack_alloc(T, C) (T*)alloca(sizeof(T)*(C)) +#define zero_mem(I, L) memset(I, 0, L) + +#define max(a, b) (a < b ? b : a) +#define min(a, b) (a < b ? a : b) +#define clamp(x, minv, maxv) (max(minv, min(x, maxv))) + +static HINSTANCE g_hinstance = NULL; + +typedef struct wog_Window +{ + HWND hwnd; // Window handler + HINSTANCE hInstance; + HDC hdc; // Device Context + HDC mdc; // Memory Device Contexts +#if WOG_API == WOG_GDI + wog_Surface* surface; // render buffer +#endif + int mouse_capture; // mouse capture count +}wog_Window; + +#if WOG_API == WOG_GL +typedef struct wog_GLContext +{ + HGLRC hrc; // Rendering Context +}wog_GLContext; +#endif + +// A mouse capture count is used +void wog_setMouseCapture(wog_Window* wnd) +{ + if (wnd->mouse_capture <= 0) + { + SetCapture(wnd->hwnd); + wnd->mouse_capture = 0; + } + ++wnd->mouse_capture; +} + +void wog_releaseMouseCapture(wog_Window* wnd) +{ + --wnd->mouse_capture; + if (wnd->mouse_capture <= 0) + ReleaseCapture(); +} + +void wog_handleEvent(wog_Window* window, MSG* msg, wog_Event* e) +{ + UINT uMsg; + WPARAM wParam; + LPARAM lParam; + uMsg = msg->message; + wParam = msg->wParam; + lParam = msg->lParam; + HWND hWnd = window->hwnd; + + switch (uMsg) + { + case WM_SYSCOMMAND: + { + switch (wParam) + { + case SC_SCREENSAVE: + case SC_MONITORPOWER: + return ; + } + break; + } + return ; + + case WM_CLOSE: + { + zero_mem(e, sizeof(wog_Event)); + e->type = WOG_ECLOSE; + return ; + } + + case WM_KEYDOWN: + case WM_SYSKEYDOWN: + if ((wParam >= 0) && (wParam <= 255)) + { + zero_mem(e, sizeof(wog_Event)); + e->type = WOG_EKEYDOWN; + e->key = wParam; + + return ; + } + break; + + case WM_KEYUP: + case WM_SYSKEYUP: + if ((wParam >= 0) && (wParam <= 255)) + { + zero_mem(e, sizeof(wog_Event)); + e->type = WOG_EKEYUP; + e->key = wParam; + + return ; + } + break; + + case WM_MOUSEMOVE: + { + zero_mem(e, sizeof(wog_Event)); + e->type = WOG_EMOUSEMOTION; + wog_getMouse(window, &e->pos.x, &e->pos.y); + return ; + } + + case WM_MOUSEWHEEL: // mousewheel scroll + { + int zDelta = GET_WHEEL_DELTA_WPARAM(wParam); + zero_mem(e, sizeof(wog_Event)); + e->type = WOG_EMOUSEWHEEL; + e->wheel = zDelta > 0 ? 1 : -1; + return ; + } + + case WM_LBUTTONDOWN: + { + zero_mem(e, sizeof(wog_Event)); + e->type = WOG_EMOUSEBUTTONDOWN; + e->button = WOG_MOUSE_LBUTTON; + wog_getMouse(window, &e->pos.x, &e->pos.y); + wog_setMouseCapture(window); + return ; + } + + case WM_RBUTTONDOWN: + { + zero_mem(e, sizeof(wog_Event)); + e->type = WOG_EMOUSEBUTTONDOWN; + e->button = WOG_MOUSE_RBUTTON; + wog_getMouse(window, &e->pos.x, &e->pos.y); + wog_setMouseCapture(window); + return ; + } + + case WM_MBUTTONDOWN: + { + zero_mem(e, sizeof(wog_Event)); + e->type = WOG_EMOUSEBUTTONDOWN; + e->button = WOG_MOUSE_MIDDLE; + wog_getMouse(window, &e->pos.x, &e->pos.y); + wog_setMouseCapture(window); + return ; + } + + case WM_LBUTTONUP: + { + zero_mem(e, sizeof(wog_Event)); + e->type = WOG_EMOUSEBUTTONUP; + e->button = WOG_MOUSE_LBUTTON; + wog_getMouse(window, &e->pos.x, &e->pos.y); + wog_releaseMouseCapture(window); + return ; + } + + case WM_RBUTTONUP: + { + zero_mem(e, sizeof(wog_Event)); + e->type = WOG_EMOUSEBUTTONUP; + e->button = WOG_MOUSE_RBUTTON; + wog_getMouse(window, &e->pos.x, &e->pos.y); + wog_releaseMouseCapture(window); + return ; + } + + case WM_MBUTTONUP: + { + zero_mem(e, sizeof(wog_Event)); + e->type = WOG_EMOUSEBUTTONUP; + e->button = WOG_MOUSE_MIDDLE; + wog_getMouse(window, &e->pos.x, &e->pos.y); + wog_releaseMouseCapture(window); + return ; + } + + case WM_PAINT: + + UpdateWindow(window->hwnd); + + return 0; + + break; + + default: + e->type = WOG_EUNKNOWN; + break; + } + DefWindowProc(hWnd, uMsg, wParam, lParam); + return ; +} + + +int wog_pollEvent(wog_Window* wnd, wog_Event* e) +{ + MSG msg; + if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) + { + if (msg.message == WM_QUIT) return 0; + TranslateMessage(&msg); + wog_handleEvent(wnd, &msg, e); + return 1; + } + return 0; +} + + +// on size changed callback; +static wog_Callback onSizeChanged = 0; +static wog_Callback onQuit = 0; + + +static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + // Get The Window Context + wog_Window* window = (wog_Window*)(GetWindowLong(hWnd, GWL_USERDATA)); + + // call callback functions +#define call(callback)\ + if (callback) \ + callback(window) + + switch (uMsg) + { + case WM_CREATE: + { + CREATESTRUCT* creation = (CREATESTRUCT*)(lParam); // Store Window Structure Pointer + window = (wog_Window*)(creation->lpCreateParams); // Get wog_Window + SetWindowLong(hWnd, GWL_USERDATA, (LONG)(window)); // Save it + } + return 0; + + case WM_CLOSE: // Post WM_CLOSE to message queue. + PostMessage(hWnd, WM_CLOSE, wParam, lParam); + return 0; + + case WM_SIZE: + call(onSizeChanged); + return 0; + + case WM_QUIT: + call(onQuit); + return 0; + + } + + return DefWindowProc(hWnd, uMsg, wParam, lParam); +#undef call +} + + +void wog_registerResizeCallback(wog_Callback cal) +{ + onSizeChanged = cal; +} + + +void wog_registerQuitCallback(wog_Callback cal) +{ + onQuit = cal; +} + +#if WOG_API == WOG_GDI +wog_Surface* wog_getsurface(wog_Window* wnd) { + return wnd->surface; +} +#endif + +static int registerWindowClass() +{ + // Register A Window Class + WNDCLASSEX windowClass; // Window Class + zero_mem(&windowClass, sizeof(WNDCLASSEX)); // Make Sure Memory Is Cleared + + windowClass.cbSize = sizeof(WNDCLASSEX); // Size Of The windowClass Structure + windowClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraws The Window For Any Movement / Resizing + windowClass.lpfnWndProc = (WNDPROC)(WindowProc); // WindowProc Handles Messages + windowClass.hInstance = g_hinstance; // Set The Instance + windowClass.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE); // Class Background Brush Color + windowClass.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer + windowClass.lpszClassName = WINDOW_CLASS; // Sets The Applications Classname + //windowClass.hIcon = (HICON)LoadIcon(g_hinstance, "icon.ico"); + + if (RegisterClassEx(&windowClass) == 0) // Did Registering The Class Fail? + { + // NOTE: Failure, Should Never Happen + MessageBox(HWND_DESKTOP, "RegisterClassEx Failed!", "Error", MB_OK | MB_ICONEXCLAMATION); + return FALSE; // Return False (Failure) + } + return TRUE; +} + +/* + * for memory device context, see + * https://docs.microsoft.com/en-us/windows/desktop/gdi/memory-device-contexts + * also + * SDL_windowsframebuffer.c WIN_CreateWindowFramebuffer + */ +static void create_surface(wog_Window* wnd, int width, int height) { + BITMAPINFOHEADER bi_header; + HDC memory_dc; + HBITMAP dib_bitmap; + HBITMAP old_bitmap; + unsigned char *buffer; // color buffer + wog_Surface *surface; + + memory_dc = CreateCompatibleDC(wnd->hdc); /*memory device contexts*/ + + memset(&bi_header, 0, sizeof(BITMAPINFOHEADER)); + bi_header.biSize = sizeof(BITMAPINFOHEADER); + bi_header.biWidth = width; + bi_header.biHeight = -height; /* top-down */ + bi_header.biPlanes = 1; + bi_header.biBitCount = 32; + bi_header.biCompression = BI_RGB; + /*create bitmap*/ + dib_bitmap = CreateDIBSection(memory_dc, (BITMAPINFO*)&bi_header, DIB_RGB_COLORS, (void**)&buffer, NULL, 0); + assert(dib_bitmap != NULL); + old_bitmap = (HBITMAP)SelectObject(memory_dc, dib_bitmap); + DeleteObject(old_bitmap); + + surface = (wog_Surface*)malloc(sizeof(wog_Surface)); + surface->width = width; + surface->height = height; + surface->channels = 4; + surface->buffer = buffer; + +#if WOG_API == WOG_GDI + wnd->surface = surface; +#endif + wnd->mdc = memory_dc; +} + + +wog_Window* wog_createWindow(const char* title, int width, int height, int x, int y, uint32 flags) +{ + int client_w = width, client_h = height; + + if (g_hinstance == NULL) + { + g_hinstance = GetModuleHandle(NULL); + } + + if (! registerWindowClass()) + { + printf("Register window class failed.\n"); + return 0; + } + + wog_Window* wnd = heap_alloc(wog_Window, 1); + zero_mem(wnd, sizeof(wog_Window)); + + DWORD windowStyle = 0; // Define Our Window Style + windowStyle |= WS_POPUP; + windowStyle |= WS_OVERLAPPED; + windowStyle |= WS_CAPTION; + windowStyle |= WS_SYSMENU; + windowStyle |= WS_MINIMIZEBOX; + windowStyle |= WS_MAXIMIZEBOX; + //windowStyle |= WS_VISIBLE; +#define hasbit(fs, f) ((fs & f) == f) + /*if (hasbit(flags, WOG_RESIZABLE)) */windowStyle |= WS_SIZEBOX; + if (hasbit(flags, WOG_DISABLE)) windowStyle |= WS_DISABLED; + + DWORD windowExtendedStyle = WS_EX_APPWINDOW; // Define The Window's Extended Style + RECT windowRect = { 0, 0, width, height }; + AdjustWindowRectEx(&windowRect, windowStyle, 0, windowExtendedStyle); + width = windowRect.right - windowRect.left; + height = windowRect.bottom - windowRect.top; + wnd->hwnd = CreateWindowEx( + windowExtendedStyle, + WINDOW_CLASS, + title, + windowStyle, + x, y, + width, height, + HWND_DESKTOP, + 0, + GetModuleHandle(NULL), + wnd + ); + + wnd->hInstance = g_hinstance; + + if (wnd->hwnd == 0) + return 0; + + if (hasbit(flags, WOG_HIDDEN)) wog_hide(wnd); + + // init device context + wnd->hdc = GetDC(wnd->hwnd); + if (wnd->hdc== 0) + { + DestroyWindow(wnd->hwnd); + wnd->hwnd = 0; + return 0; + } + + wnd->mouse_capture = 0; + +#if WOG_API == WOG_GDI + create_surface(wnd, client_w, client_h); +#endif + +#if WOG_API == WOG_GL + PIXELFORMATDESCRIPTOR pfd = // pfd Tells Windows How We Want Things To Be + { + sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor + 1, // Version Number + PFD_DRAW_TO_WINDOW | // Format Must Support Window + PFD_SUPPORT_OPENGL | // Format Must Support OpenGL + PFD_DOUBLEBUFFER, // Must Support Double Buffering + PFD_TYPE_RGBA, // Request An RGBA Format + 32, // Select Our Color Depth + 0, 0, 0, 0, 0, 0, // Color Bits Ignored + 0, // No Alpha Buffer + 0, // Shift Bit Ignored + 0, // No Accumulation Buffer + 0, 0, 0, 0, // Accumulation Bits Ignored + 16, // 16Bit Z-Buffer (Depth Buffer) + 0, // No Stencil Buffer + 0, // No Auxiliary Buffer + PFD_MAIN_PLANE, // Main Drawing Layer + 0, // Reserved + 0, 0, 0 // Layer Masks Ignored + }; + // set pixel format + unsigned int pixelformat; + pixelformat = ChoosePixelFormat(wnd->hdc, &pfd); + if (pixelformat == 0) + { + wog_destroyWindow(wnd); + return 0; + } + + // set pixel format + if (SetPixelFormat(wnd->hdc, pixelformat, &pfd) == 0 ) + { + wog_destroyWindow(wnd); + return 0; + } +#endif + + return wnd; +} + +#if WOG_API == WOG_GL +wog_GLContext* wog_createGLContext(wog_Window* wnd) +{ + wog_GLContext* cxt = heap_alloc(wog_GLContext, 1); + zero_mem(cxt, sizeof(wog_GLContext)); + cxt->hrc = wglCreateContext(wnd->hdc); // create opengl context base on device context + if (cxt->hrc == 0) + { + free(cxt); + return 0; + } + return cxt; +} +#endif + +#if WOG_API == WOG_GL +int wog_makeCurrent(wog_Window* wnd, wog_GLContext* cxt) +{ + if (wnd && cxt) + { + if (wglMakeCurrent(wnd->hdc, cxt->hrc) == 0) + { + return 0; + } + return 1; + } + + return 0; +} +#endif + +#if WOG_API == WOG_GL +void wog_destroyGLContext(wog_GLContext* cxt) +{ + if (cxt && cxt->hrc) + { + wglDeleteContext(cxt->hrc); + free(cxt); + } +} +#endif + +#if WOG_API == WOG_GDI +void wog_updateSurface(wog_Window* wnd) { + if(wnd->surface == NULL) return ; + int width = wnd->surface->width, height = wnd->surface->height; + BitBlt(wnd->hdc, 0, 0, wnd->surface, height, wnd->mdc, 0, 0, SRCCOPY); +} +#endif + +void wog_destroyWindow(wog_Window* wnd) +{ + if (wnd) + { + ReleaseDC(wnd->hwnd, wnd->hdc); + DestroyWindow(wnd->hwnd); + free(wnd); + } +} + + +static void UnEscapeQuotes(char *arg) +{ + char *last = NULL; + + while (*arg) { + if (*arg == '"' && *last == '\\') { + char *c_curr = arg; + char *c_last = last; + + while (*c_curr) { + *c_last = *c_curr; + c_last = c_curr; + c_curr++; + } + *c_last = '\0'; + } + last = arg; + arg++; + } +} + + +/* Parse a command line buffer into arguments */ +static int ParseCommandLine(char *cmdline, char **argv) +{ + char *bufp; + char *lastp = NULL; + int argc, last_argc; + + argc = last_argc = 0; + for (bufp = cmdline; *bufp; ) { + /* Skip leading whitespace */ + while (isspace(*bufp)) { + ++bufp; + } + /* Skip over argument */ + if (*bufp == '"') { + ++bufp; + if (*bufp) { + if (argv) { + argv[argc] = bufp; + } + ++argc; + } + /* Skip over word */ + while (*bufp && (*bufp != '"' || (lastp && *lastp == '\\'))) { + lastp = bufp; + ++bufp; + } + } + else { + if (*bufp) { + if (argv) { + argv[argc] = bufp; + } + ++argc; + } + /* Skip over word */ + while (*bufp && !isspace(*bufp)) { + ++bufp; + } + } + if (*bufp) { + if (argv) { + *bufp = '\0'; + } + ++bufp; + } + + /* Strip out \ from \" sequences */ + if (argv && last_argc != argc) { + UnEscapeQuotes(argv[last_argc]); + } + last_argc = argc; + } + if (argv) { + argv[argc] = NULL; + } + return(argc); +} + + +#ifdef main +#undef main +#endif + + +#if defined(_MSC_VER) && !defined(_WIN32_WCE) +/* The VC++ compiler needs main defined */ +#define console_main main +#endif + +extern int wog_main(int argc, char* argv[]); + +/** +* Entry of console application. +*/ +int console_main(int argc, char* argv[]) +{ + int status = wog_main(argc, argv); + return status; +} + + +/** +* Entry of windows application. +*/ +int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw) +{ + g_hinstance = hInst; + + char* temp = GetCommandLine(); + int len = strlen(temp) + 1; + char* cmd = stack_alloc(char, len); + strcpy(cmd, temp); + cmd[len - 1] = '\0'; + + int argc = 0; + char** argv = 0; + argc = ParseCommandLine(cmd, 0); + ParseCommandLine(cmd, 0); + argv = stack_alloc(char*, argc + 1); + ParseCommandLine(cmd, argv); + + int status = console_main(argc, argv); + + return status; +} + + +void wog_swapBuffers(wog_Window* wnd) +{ + if (wnd) + { + SwapBuffers(wnd->hdc); + } +} + + +void wog_getMouse(wog_Window* wnd, int *x, int *y) +{ + POINT p; + GetCursorPos(&p); + ScreenToClient(wnd->hwnd, &p); + int w, h; + wog_getwindowsize(wnd, &w, &h); + //*x = clamp(p.x, 0, w); + //*y = clamp(p.y, 0, h); + *x = p.x; + *y = p.y; +} + + +void wog_getwindowsize(wog_Window* wnd, int* width, int* height) +{ + RECT r; + GetClientRect(wnd->hwnd, &r); + *width = r.right; + *height = r.bottom; +} + + +void wog_show(wog_Window* wnd) +{ + ShowWindow(wnd->hwnd, SW_SHOW); +} + + +void wog_hide(wog_Window* wnd) +{ + ShowWindow(wnd->hwnd, SW_HIDE); +} + + +void wog_sleep(int ms) +{ + Sleep(ms); +} + +int wog_tick() +{ + return GetTickCount(); +} + + +void wog_setcursor(wog_Window* wnd, unsigned int cursor) +{ + SetCursor(LoadCursor(NULL, cursor)); +} + +//void wog_setcursorImage(wog_Window* wnd, const char* path) +//{ +// SetCursor(LoadImageA(NULL, path, IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR | LR_CREATEDIBSECTION | LR_LOADFROMFILE)); +// printf("wog_setcursorImage\n"); +//} + +void wog_setcursorImage(wog_Window* wnd, Wog_Cursor icon) +{ + SetCursor(icon); +} + +HINSTANCE wog_get_instance() +{ + return g_hinstance; +} |