Commit: ae2115beca5eef14279ba02fa7c5c4842a825332 - glow (git)

Cross-Platform OpenGL Windowing Library

Commit MetaInfo

• Revision: ae2115beca5eef14279ba02fa7c5c4842a825332 (tree)
• Time: 2019-04-13 15:10:10
• Author: AlaskanEmily <emily@alas...>
• Commiter: AlaskanEmily

Log Message

Add SDL2 backend

Change Summary

• modified: gcc.mk
• add: glow_sdl2.c
• modified: nmakefile

Incremental Difference

--- a/gcc.mk
+++ b/gcc.mk
@@ -17,7 +17,13 @@ glow_x11.o: glow_x11.c glow.h
 	$(CC) $(CFLAGS) $(X11INCLUDE) -c glow_x11.c -o glow_x11.o
 
 glow_x11.os: glow_x11.c glow.h
-	$(CC) $(CFLAGS)$(FPICFLAGS) $(X11INCLUDE) -c glow_x11.c -o glow_x11.os
+	$(CC) $(CFLAGS) $(FPICFLAGS) $(X11INCLUDE) -c glow_x11.c -o glow_x11.os
+
+glow_sdl2.o: glow_sdl2.c glow.h
+	$(CC) $(CFLAGS) -c glow_sdl2.c -o glow_sdl2.o
+
+glow_sdl2.os: glow_sdl2.c glow.h
+	$(CC) $(CFLAGS) $(FPICFLAGS) -c glow_sdl2.c -o glow_sdl2.os
 
 libglow.so: glow_$(GLOWTARGET).os
 	$(LINKER) $(SHAREDFLAGS) glow_$(GLOWTARGET).os -o libglow.so

--- /dev/null
+++ b/glow_sdl2.c
@@ -0,0 +1,332 @@
+/* Copyright (C) 2019 Alaskan Emily, Transnat Games
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "glow.h"
+#include "SDL.h"
+#include "SDL_video.h"
+#include "SDL_syswm.h"
+
+/******************************************************************************/
+
+struct Glow_Context{
+    SDL_Window *win;
+    SDL_GLContext ctx;
+};
+
+/******************************************************************************/
+
+struct Glow_Window{
+    SDL_Window *win;
+    struct Glow_Context ctx;
+};
+
+/******************************************************************************/
+
+void Glow_ViewportSize(unsigned w, unsigned h,
+    unsigned *out_w, unsigned *out_h){
+    out_w[0] = w;
+    out_h[0] = h;
+}
+
+/******************************************************************************/
+
+void *Glow_GetSystemWindow(struct Glow_Window *window){
+    SDL_SysWMinfo info;
+    if(!SDL_GetWindowWMInfo(window->win, &info))
+        return NULL;
+    switch(info.subsystem){
+#ifdef SDL_VIDEO_DRIVER_WINDOWS
+        case SDL_SYSWM_WINDOWS:
+            return (void*)info.info.win.window;
+#endif
+        
+#ifdef SDL_VIDEO_DRIVER_WINRT
+        case SDL_SYSWM_WINRT:
+            return info.info.winrt.window;
+#endif
+        
+#ifdef SDL_VIDEO_DRIVER_MIR
+        case SDL_SYSWM_MIR:
+            return info.info.mir.surface;
+#endif
+        
+#ifdef SDL_VIDEO_DRIVER_WAYLAND
+        case SDL_SYSWM_WAYLAND:
+            return info.info.wl.surface;
+#endif
+        
+#ifdef SDL_VIDEO_DRIVER_X11
+        case SDL_SYSWM_X11:
+            return (void*)info.info.x11.window;
+#endif
+        
+#ifdef SDL_VIDEO_DRIVER_DIRECTFB
+        case SDL_SYSWM_DIRECTFB:
+            return info.info.dfb.window;
+#endif
+        
+#ifdef SDL_VIDEO_DRIVER_COCOA
+        case SDL_SYSWM_COCOA:
+            return info.info.cocoa.window;
+#endif
+        
+#ifdef SDL_VIDEO_DRIVER_UIKIT
+        case SDL_SYSWM_UIKIT:
+            return info.info.uikit.window;
+#endif
+        case SDL_SYSWM_UNKNOWN: /* FALLTHROUGH */
+        default:
+            return NULL;
+    }
+}
+
+/******************************************************************************/
+
+void *Glow_GetProcAddress(const char *name){
+    return SDL_GL_GetProcAddress(name);
+}
+
+/******************************************************************************/
+
+unsigned Glow_WindowStructSize(void){
+    return sizeof(struct Glow_Window);
+}
+
+/******************************************************************************/
+
+void Glow_CreateWindow(struct Glow_Window *out,
+    unsigned w, unsigned h, const char *title, int flags){
+    
+    int sdl_flags = SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN;
+    
+#ifdef SDL_WINDOW_ALLOW_HIGHDPI
+    sdl_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
+#endif
+    
+    if((flags & GLOW_RESIZABLE) != 0)
+        sdl_flags |= SDL_WINDOW_RESIZABLE;
+    if((flags & GLOW_UNDECORATED) != 0)
+        sdl_flags |= SDL_WINDOW_BORDERLESS;
+    
+    /* This is used every time a window is created. SDL2 ref-counts this, so
+     * it is OK to use this on window construction and a matched quit occurs on
+     * window destruction.
+     */
+    SDL_InitSubSystem(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK|SDL_INIT_EVENTS);
+    
+    out->ctx.win = out->win = SDL_CreateWindow(title,
+        SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, w, h, sdl_flags);
+    out->ctx.ctx = NULL;
+}
+
+/******************************************************************************/
+
+void Glow_DestroyWindow(struct Glow_Window *win){
+    SDL_DestroyWindow(win->win);
+    if(win->ctx.ctx != NULL)
+        SDL_GL_DeleteContext(win->ctx.ctx);
+    SDL_QuitSubSystem(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK|SDL_INIT_EVENTS);
+}
+
+/******************************************************************************/
+
+void Glow_SetTitle(struct Glow_Window *win, const char *title){
+    SDL_SetWindowTitle(win->win, title);
+}
+
+/******************************************************************************/
+
+void Glow_ShowWindow(struct Glow_Window *win){
+    SDL_ShowWindow(win->win);
+    SDL_RaiseWindow(win->win);
+}
+
+/******************************************************************************/
+
+void Glow_HideWindow(struct Glow_Window *win){
+    SDL_HideWindow(win->win);
+}
+
+/******************************************************************************/
+
+void Glow_GetWindowSize(const struct Glow_Window *win,
+    unsigned *out_w, unsigned *out_h){
+
+    int w, h;
+    SDL_GetWindowSize(win->win, &w, &h);
+    out_w[0] = w;
+    out_h[0] = h;
+}
+
+/******************************************************************************/
+
+void Glow_FlipScreen(struct Glow_Window *win){
+    SDL_GL_SwapWindow(win->win);
+}
+
+/******************************************************************************/
+
+static int glow_write_keyname(const SDL_Event *in, struct Glow_Event *out){
+    const char *const name = SDL_GetKeyName(in->key.keysym.sym);
+#if defined _WIN32 || defined __CYGWIN__ || defined WIN32
+    strncpy(out->value.key, name, GLOW_MAX_KEY_NAME_SIZE-2);
+    out->value.key[GLOW_MAX_KEY_NAME_SIZE-1] = 0;
+#else
+    strlcpy(out->value.key, name, GLOW_MAX_KEY_NAME_SIZE-1);
+#endif
+    return 1;
+}
+
+/******************************************************************************/
+
+static enum Glow_MouseButton glow_translate_button(unsigned s){
+    if((s & SDL_BUTTON_LMASK) != 0)
+        return eGlowLeft;
+    if((s & SDL_BUTTON_RMASK) != 0)
+        return eGlowRight;
+    if((s & SDL_BUTTON_MMASK) != 0)
+        return eGlowMiddle;
+    return eGlow_NUM_BUTTONS;
+}
+
+/******************************************************************************/
+
+static int glow_convert_sdl2_event(const SDL_Event *in,
+    struct Glow_Event *out){
+    
+    switch(in->type){
+        case SDL_QUIT:
+        case SDL_APP_TERMINATING:
+            out->type = eGlowQuit;
+            return 1;
+        case SDL_KEYDOWN:
+            out->type = eGlowKeyboardPressed;
+            return glow_write_keyname(in, out);
+        case SDL_KEYUP:
+            out->type = eGlowKeyboardReleased;
+            return glow_write_keyname(in, out);
+        case SDL_MOUSEMOTION:
+            out->type = eGlowMouseMoved;
+            out->value.mouse.xy[0] = in->motion.x;
+            out->value.mouse.xy[1] = in->motion.y;
+            out->value.mouse.button = glow_translate_button(in->motion.state);
+            return 1;
+        case SDL_MOUSEBUTTONDOWN:
+            out->type = eGlowMousePressed;
+            out->value.mouse.xy[0] = in->button.x;
+            out->value.mouse.xy[1] = in->button.y;
+            out->value.mouse.button = glow_translate_button(in->button.state);
+            return 1;
+        case SDL_MOUSEBUTTONUP:
+            out->type = eGlowMouseReleased;
+            out->value.mouse.xy[0] = in->button.x;
+            out->value.mouse.xy[1] = in->button.y;
+            out->value.mouse.button = glow_translate_button(in->button.state);
+            return 1;
+        case SDL_WINDOWEVENT:
+            switch(in->window.event){
+                case SDL_WINDOWEVENT_SIZE_CHANGED: /* FALLTHROUGH */
+                case SDL_WINDOWEVENT_RESIZED:
+                    out->type = eGlowResized;
+                    out->value.resize[0] = in->window.data1;
+                    out->value.resize[1] = in->window.data2;
+                    return 1;
+            }
+            break;
+    }
+    
+    return 0;
+}
+
+/******************************************************************************/
+
+unsigned Glow_GetEvent(struct Glow_Window *win, struct Glow_Event *out_event){
+    
+    SDL_Event ev;
+    (void)win;
+    
+    while(SDL_PollEvent(&ev)){
+        if(glow_convert_sdl2_event(&ev, out_event))
+            return 1;
+    }
+    
+    return 0;
+}
+
+/******************************************************************************/
+
+void Glow_WaitEvent(struct Glow_Window *win, struct Glow_Event *out_event){
+    
+    SDL_Event ev;
+    (void)win;
+    
+    do{
+        SDL_WaitEvent(&ev);
+    }while(!glow_convert_sdl2_event(&ev, out_event));
+}
+
+/******************************************************************************/
+
+unsigned Glow_ContextStructSize(void){
+    return sizeof(struct Glow_Context);
+}
+
+/******************************************************************************/
+
+int Glow_CreateContext(struct Glow_Window *win,
+    struct Glow_Context *opt_share,
+    unsigned major, unsigned minor,
+    struct Glow_Context *out){
+    
+    if(opt_share != NULL){
+        SDL_GL_MakeCurrent(win->win, opt_share->ctx);
+        SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1);
+    }
+    else{
+        SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 0);
+    }
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor);
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
+        SDL_GL_CONTEXT_PROFILE_CORE);
+    out->ctx = SDL_GL_CreateContext(win->win);
+    out->win = win->win;
+    return 0;
+}
+
+/******************************************************************************/
+
+void Glow_CreateLegacyContext(struct Glow_Window *win,
+    struct Glow_Context *out){
+    
+    SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 0);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
+        SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);
+    win->ctx.ctx = SDL_GL_CreateContext(win->win);
+    if(out)
+        out->ctx = win->ctx.ctx;
+}
+
+/******************************************************************************/
+
+void Glow_MakeCurrent(struct Glow_Context *ctx){
+    SDL_GL_MakeCurrent(ctx->win, ctx->win);
+}
+
+/******************************************************************************/
+
+struct Glow_Window *Glow_CreateLegacyWindow(
+    unsigned w, unsigned h, const char *title){
+    
+    struct Glow_Window *const win = malloc(sizeof(struct Glow_Window));
+    Glow_CreateWindow(win, w, h, title, 0);
+    Glow_CreateLegacyContext(win, NULL);
+    return win;
+}

--- a/nmakefile
+++ b/nmakefile
@@ -12,6 +12,12 @@ glow.lib: glow_win32.obj
 glow.dll: glow_win32.obj
 	link /nologo /dll /out:glow.dll /implib:glow.lib OpenGL32.lib gdi32.lib user32.lib glow_win32.obj
 
+glow_sdl2.obj: glow_sdl2.c glow.h
+	cl /I"$(MAKEDIR)\include" /DGLOW_EXPORTS /DGLOW_DLL /c glow_sdl2.c /nologo
+
+sdl2: glow_sdl2.obj
+	link /nologo /dll /out:glow.dll /implib:glow.lib sdl2.lib glow_sdl2.obj /LIBPATH:"$(MAKEDIR)\lib"
+	
 clean:
 	del glow.dll > nul || echo > nul
 	del glow.lib > nul || echo > nul