Commit: 2cbe4e6af63e182d33f1a0974b0c01fa5e60361f - glow (git)

Cross-Platform OpenGL Windowing Library

Commit MetaInfo

• Revision: 2cbe4e6af63e182d33f1a0974b0c01fa5e60361f (tree)
• Time: 2020-01-04 17:57:28
• Author: AlaskanEmily <emily@alas...>
• Commiter: AlaskanEmily

Log Message

Add VSync and Adaptive VSync flags to Glow_CreateWindow

Change Summary

• modified: glow.h
• modified: glow_sdl2.c
• modified: glow_win32.c

Incremental Difference

--- a/glow.h
+++ b/glow.h
@@ -28,6 +28,14 @@ extern "C" {
 /* Flags for Glow_CreateWindow */
 #define GLOW_RESIZABLE   (1<<0)
 #define GLOW_UNDECORATED (1<<1)
+#define GLOW_VSYNC       (1<<2)
+
+/* Enables adaptive VSync, if the OpenGL context supports it. If it does not,
+ * then Glow will fall back to regular VSync if that flag is also specified.
+ * If only the adaptive VSync flag was set, and adaptive VSync is not
+ * supported, then no VSync will be enabled.
+ */
+#define GLOW_ADAPTIVE_VSYNC (1<<3)
 
 /******************************************************************************/
 

--- a/glow_sdl2.c
+++ b/glow_sdl2.c
@@ -21,6 +21,7 @@ struct Glow_Context{
 struct Glow_Window{
     SDL_Window *win;
     struct Glow_Context ctx;
+    SDL_bool vsync, adaptive_vsync;
 };
 
 /******************************************************************************/
@@ -120,6 +121,9 @@ void Glow_CreateWindow(struct Glow_Window *out,
     out->ctx.win = out->win = SDL_CreateWindow(title,
         SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, w, h, sdl_flags);
     out->ctx.ctx = NULL;
+    
+    out->vsync = (flags & GLOW_VSYNC) != 0;
+    out->adaptive_vsync = (flags & GLOW_ADAPTIVE_VSYNC) != 0;
 }
 
 /******************************************************************************/
@@ -295,6 +299,18 @@ int Glow_CreateContext(struct Glow_Window *win,
         SDL_GL_CONTEXT_PROFILE_CORE);
     out->ctx = SDL_GL_CreateContext(win->win);
     out->win = win->win;
+    
+    if(win->adaptive_vsync){
+        /* Try to set it to adaptive, otherwise fallback to regular vsync if
+         * win->vsync is set.
+         */
+        SDL_GL_SetSwapInterval(-1);
+        if(win->vsync && SDL_GL_GetSwapInterval() != -1)
+            SDL_GL_SetSwapInterval(1);
+    }
+    else if(win->vsync)
+        SDL_GL_SetSwapInterval(1);
+    
     return 0;
 }
 

--- a/glow_win32.c
+++ b/glow_win32.c
@@ -31,6 +31,7 @@ struct Glow_Window {
     HDC dc;
     HWND win;
     struct Glow_Context ctx;
+    BOOL vsync, adaptive_vsync;
 };
 
 /******************************************************************************/
@@ -178,14 +179,68 @@ static const PIXELFORMATDESCRIPTOR glow_pixel_format = {
 
 /******************************************************************************/
 
-static LRESULT WINAPI glow_window_proc(HWND wnd, UINT msg, WPARAM parm, LPARAM lparam){
+static LRESULT WINAPI glow_window_proc(HWND wnd,
+    UINT msg,
+    WPARAM parm,
+    LPARAM lparam){
+    
     if(msg == WM_CREATE){
-        struct Glow_Window *const window = (struct Glow_Window *)(((CREATESTRUCT*)lparam)->lpCreateParams);
-        const int let = ChoosePixelFormat((window->dc = GetDC(wnd)), &glow_pixel_format);
+        struct Glow_Window *const window =
+            (struct Glow_Window *)(((CREATESTRUCT*)lparam)->lpCreateParams);
+        const int let =
+            ChoosePixelFormat((window->dc = GetDC(wnd)), &glow_pixel_format);
+        
+        /* This will get set to -1 if adaptive vsync works. */
+        int interval = 1;
+        const char *const ext = glGetString(GL_EXTENSIONS);
+        
         SetPixelFormat(window->dc, let, &glow_pixel_format);
         window->ctx.ctx = wglCreateContext(window->dc);
         window->ctx.dc = window->dc;
         wglMakeCurrent(window->dc, window->ctx.ctx);
+        
+        /* Try to get VSync or, if requested, adaptive VSync. */
+        if((window->adaptive_vsync || window->vsync) &&
+            strstr(ext, "WGL_EXT_swap_control") != NULL){
+            
+            typedef BOOL(*wgl_swap_interval_func)(int);
+            
+            const wgl_swap_interval_func wglSwapIntervalEXT =
+                (wgl_swap_interval_func)wglGetProcAddress(
+                    "wglSwapIntervalEXT");
+            
+            assert(wglSwapIntervalEXT);
+            
+            /* Try to use control_tear if requested. */
+            if(window->adaptive_vsync &&
+                strstr(ext, "WGL_EXT_extensions_string") != NULL){
+                
+                typedef const char*(*wgl_extension_strings_func)(void);
+                
+                const wgl_extension_strings_func wglGetExtensionsStringEXT =
+                    (wgl_extension_strings_func)wglGetProcAddress(
+                        "wglGetExtensionsStringEXT");
+                
+                assert(wglGetExtensionsStringEXT);
+                
+                if(wglGetExtensionsStringEXT){
+                    const char *const wgl_ext = wglGetExtensionsStringEXT();
+                    if(strstr(wgl_ext, "WGL_EXT_swap_control_tear") != NULL){
+                        interval = -1;
+                    }
+                }
+            }
+            
+            /* Set the interval if either adaptive VSync or regular VSync was
+             * requested.
+             */
+            if(((window->adaptive_vsync && interval == -1) || window->vsync) &&
+                wglSwapIntervalEXT != NULL){
+                
+                wglSwapIntervalEXT(interval);
+            }
+        }
+        
         glClearColor(0.75f, 0.333f, 0.0f, 1.0f);
         SetFocus(wnd);
         return 0;
@@ -313,7 +368,15 @@ void Glow_CreateWindow(struct Glow_Window *out,
         size.bottom += (GetSystemMetrics(SM_CYFRAME) +
             GetSystemMetrics(SM_CYCAPTION) +
             GetSystemMetrics(SM_CXPADDEDBORDER));
-        out->win = CreateWindow(GLOW_CLASS_NAME, title, style, 64, 64, size.right, size.bottom, NULL, NULL, glow_app, out);
+        out->win = CreateWindow(GLOW_CLASS_NAME,
+            title,
+            style,
+            64, 64, size.right, size.bottom,
+            NULL, NULL,
+            glow_app,
+            out);
+        out->adaptive_vsync = (flags & GLOW_ADAPTIVE_VSYNC) != 0;
+        out->vsync = (flags & GLOW_VSYNC) != 0;
     }
 }