BGE: Adding vsync control. Users can enable vsync, disable vsync, or use adaptive...
authorMitchell Stokes <mogurijin@gmail.com>
Mon, 29 Jul 2013 22:31:32 +0000 (22:31 +0000)
committerMitchell Stokes <mogurijin@gmail.com>
Mon, 29 Jul 2013 22:31:32 +0000 (22:31 +0000)
22 files changed:
doc/python_api/rst/bge.render.rst
intern/ghost/GHOST_C-api.h
intern/ghost/GHOST_IWindow.h
intern/ghost/intern/GHOST_C-api.cpp
intern/ghost/intern/GHOST_Window.h
intern/ghost/intern/GHOST_WindowWin32.cpp
intern/ghost/intern/GHOST_WindowWin32.h
intern/ghost/intern/GHOST_WindowX11.cpp
intern/ghost/intern/GHOST_WindowX11.h
release/scripts/startup/bl_ui/properties_game.py
source/blender/windowmanager/intern/wm_window.c
source/blender/windowmanager/wm_window.h
source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
source/gameengine/BlenderRoutines/KX_BlenderCanvas.cpp
source/gameengine/BlenderRoutines/KX_BlenderCanvas.h
source/gameengine/BlenderRoutines/KX_BlenderGL.cpp
source/gameengine/BlenderRoutines/KX_BlenderGL.h
source/gameengine/GamePlayer/ghost/GPG_Application.cpp
source/gameengine/GamePlayer/ghost/GPG_Canvas.cpp
source/gameengine/GamePlayer/ghost/GPG_Canvas.h
source/gameengine/Ketsji/KX_PythonInit.cpp
source/gameengine/Rasterizer/RAS_ICanvas.h

index c3bcf19..5a80b7f 100644 (file)
@@ -62,6 +62,18 @@ Constants
 .. data:: KX_BLENDER_GLSL_MATERIAL
 
    Materials approximating blender materials with GLSL.
+   
+.. DATA:: VSYNC_OFF
+
+   Disables vsync
+
+.. DATA:: VSYNC_ON
+
+   Enables vsync
+
+.. DATA:: VSYNC_ADAPTIVE
+
+   Enables adaptive vsync if supported. Adaptive vsync enables vsync if the framerate is above the monitors refresh rate. Otherwise, vsync is diabled if the framerate is too low.
 
 *********
 Functions
@@ -289,3 +301,15 @@ Functions
 
    Disable the motion blur effect.
 
+.. function:: setVsync(value)
+
+   Set the vsync value
+
+   :arg value: One of VSYNC_OFF, VSYNC_ON, VSYNC_ADAPTIVE
+   :type value: integer
+
+.. function:: getVsync()
+
+   Get the current vsync value
+
+   :rtype: One of VSYNC_OFF, VSYNC_ON, VSYNC_ADAPTIVE
index a92d0d3..aae9017 100644 (file)
@@ -665,6 +665,19 @@ extern GHOST_TSuccess GHOST_SetWindowOrder(GHOST_WindowHandle windowhandle,
  */
 extern GHOST_TSuccess GHOST_SwapWindowBuffers(GHOST_WindowHandle windowhandle);
 
+/**
+ * Sets the swap interval for swapBuffers.
+ * \param interval The swap interval to use.
+ * \return A boolean success indicator.
+ */
+extern GHOST_TSuccess GHOST_SetSwapInterval(GHOST_WindowHandle windowhandle, int interval);
+
+/**
+ * Gets the current swap interval for swapBuffers.
+ * \return An integer.
+ */
+extern int GHOST_GetSwapInterval(GHOST_WindowHandle windowhandle);
+
 /**
  * Activates the drawing context of this window.
  * \param windowhandle The handle to the window
index a2d3e9b..3557707 100644 (file)
@@ -204,6 +204,19 @@ public:
         */
        virtual GHOST_TSuccess swapBuffers() = 0;
 
+       /**
+        * Sets the swap interval for swapBuffers.
+        * \param interval The swap interval to use.
+        * \return A boolean success indicator.
+        */
+       virtual GHOST_TSuccess setSwapInterval(int interval) = 0;
+
+       /**
+        * Gets the current swap interval for swapBuffers.
+        * \return An integer.
+        */
+       virtual int getSwapInterval() = 0;
+
        /**
         * Activates the drawing context of this window.
         * \return  A boolean success indicator.
index b73ff26..8d4498e 100644 (file)
@@ -691,6 +691,19 @@ GHOST_TSuccess GHOST_SwapWindowBuffers(GHOST_WindowHandle windowhandle)
        return window->swapBuffers();
 }
 
+GHOST_TSuccess GHOST_SetSwapInterval(GHOST_WindowHandle windowhandle, int interval)
+{
+       GHOST_IWindow *window = (GHOST_IWindow *) windowhandle;
+
+       return window->setSwapInterval(interval);
+}
+
+int GHOST_GetSwapInterval(GHOST_WindowHandle windowhandle)
+{
+       GHOST_IWindow *window = (GHOST_IWindow *) windowhandle;
+
+       return window->getSwapInterval();
+}
 
 
 GHOST_TSuccess GHOST_ActivateWindowDrawingContext(GHOST_WindowHandle windowhandle)
index 588de09..77ee4db 100644 (file)
@@ -67,6 +67,8 @@ public:
         * virtual GHOST_TWindowOrder getOrder(void) = 0;
         * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
         * virtual GHOST_TSuccess swapBuffers() = 0;
+        * virtual GHOST_TSuccess setSwapInterval() = 0;
+        * virtual int getSwapInterval() = 0;
         * virtual GHOST_TSuccess activateDrawingContext() = 0;
         * virtual GHOST_TSuccess invalidate() = 0;
         */
@@ -110,6 +112,8 @@ public:
         * virtual GHOST_TSuccess setState(GHOST_TWindowState state) = 0;
         * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0;
         * virtual GHOST_TSuccess swapBuffers() = 0;
+        * virtual GHOST_TSuccess setSwapInterval() = 0;
+        * virtual int getSwapInterval() = 0;
         * virtual GHOST_TSuccess activateDrawingContext() = 0;
         * virtual GHOST_TSuccess invalidate() = 0;
         */
@@ -204,6 +208,23 @@ public:
                return GHOST_kFailure;
        }
        
+       /**
+        * Sets the swap interval for swapBuffers.
+        * \param interval The swap interval to use.
+        * \return A boolean success indicator.
+        */
+       virtual GHOST_TSuccess setSwapInterval(int interval) {
+               return GHOST_kFailure;
+       }
+       
+       /**
+        * Gets the current swap interval for swapBuffers.
+        * \return An integer.
+        */
+       virtual int getSwapInterval() {
+               return 0;
+       }
+       
        /**
         * Tells if the ongoing drag'n'drop object can be accepted upon mouse drop
         */
index b0d0b1a..c264686 100644 (file)
@@ -648,6 +648,20 @@ GHOST_TSuccess GHOST_WindowWin32::swapBuffers()
        return ::SwapBuffers(hDC) == TRUE ? GHOST_kSuccess : GHOST_kFailure;
 }
 
+GHOST_TSuccess GHOST_WindowWin32::setSwapInterval(int interval)
+{
+       if (!WGL_EXT_swap_control)
+               return GHOST_kFailure;
+       return wglSwapIntervalEXT(interval) == TRUE ? GHOST_kSuccess : GHOST_kFailure;
+}
+
+int GHOST_WindowWin32::getSwapInterval()
+{
+       if (WGL_EXT_swap_control)
+               return wglGetSwapIntervalEXT();
+
+       return 0;
+}
 
 GHOST_TSuccess GHOST_WindowWin32::activateDrawingContext()
 {
index 2fd1f5b..6fdc963 100644 (file)
@@ -211,6 +211,19 @@ public:
         */
        virtual GHOST_TSuccess swapBuffers();
 
+       /**
+        * Sets the swap interval for swapBuffers.
+        * \param interval The swap interval to use.
+        * \return A boolean success indicator.
+        */
+       virtual GHOST_TSuccess setSwapInterval(int interval);
+
+       /**
+        * Gets the current swap interval for swapBuffers.
+        * \return An integer.
+        */
+       virtual int getSwapInterval();
+
        /**
         * Activates the drawing context of this window.
         * \return Indication of success.
index 25d7c18..3173736 100644 (file)
@@ -30,6 +30,8 @@
  */
 
 
+#include <GL/glxew.h>
+
 #include "GHOST_WindowX11.h"
 #include "GHOST_SystemX11.h"
 #include "STR_String.h"
@@ -1513,3 +1515,23 @@ endFullScreen() const
 
        return GHOST_kSuccess;
 }
+
+GHOST_TSuccess
+GHOST_WindowX11::
+setSwapInterval(int interval) {
+       if (!GLX_EXT_swap_control)
+               return GHOST_kFailure;
+       glXSwapIntervalEXT(m_display, m_window, interval);
+       return GHOST_kSuccess;
+}
+
+int
+GHOST_WindowX11::
+getSwapInterval() {
+       if (GLX_EXT_swap_control) {
+               unsigned int value;
+               glXQueryDrawable(m_display, m_window, GLX_SWAP_INTERVAL_EXT, &value);
+               return (int)value;
+       }
+       return 0;
+}
index b8471b4..7cbdcde 100644 (file)
@@ -235,6 +235,19 @@ public:
 
        GHOST_TSuccess endFullScreen() const;
 
+       /**
+        * Sets the swap interval for swapBuffers.
+        * \param interval The swap interval to use.
+        * \return A boolean success indicator.
+        */
+       virtual GHOST_TSuccess setSwapInterval(int interval);
+
+       /**
+        * Gets the current swap interval for swapBuffers.
+        * \return An integer.
+        */
+       virtual int getSwapInterval();
+
 protected:
        /**
         * Tries to install a rendering context in this window.
index 38e4985..025d862 100644 (file)
@@ -413,6 +413,9 @@ class RENDER_PT_game_system(RenderButtonsPanel, Panel):
         col.prop(gs, "use_display_lists")
         col.active = gs.raster_storage != 'VERTEX_BUFFER_OBJECT'
 
+        row = layout.row()
+        row.prop(gs, "vsync")
+
         row = layout.row()
         row.prop(gs, "raster_storage")
 
index 70541f7..062107f 100644 (file)
@@ -1324,6 +1324,16 @@ void wm_window_swap_buffers(wmWindow *win)
 #endif
 }
 
+void wm_window_set_swap_interval (wmWindow *win, int interval)
+{
+       GHOST_SetSwapInterval(win->ghostwin, interval);
+}
+
+int wm_window_get_swap_interval (wmWindow *win)
+{
+       return GHOST_GetSwapInterval(win->ghostwin);
+}
+
 
 /* ******************* exported api ***************** */
 
index 22fa242..d7e938f 100644 (file)
@@ -58,6 +58,8 @@ void          wm_window_lower                 (wmWindow *win);
 void           wm_window_set_size              (wmWindow *win, int width, int height);
 void           wm_window_get_position  (wmWindow *win, int *posx_r, int *posy_r);
 void           wm_window_swap_buffers  (wmWindow *win);
+void           wm_window_set_swap_interval     (wmWindow *win, int interval);
+int                    wm_window_get_swap_interval     (wmWindow *win);
 
 void           wm_get_cursor_position  (wmWindow *win, int *x, int *y);
 
index bb4c3fd..5703527 100644 (file)
@@ -284,6 +284,14 @@ extern "C" void StartKetsjiShell(struct bContext *C, struct ARegion *ar, rcti *c
                        canvas->SetMouseState(RAS_ICanvas::MOUSE_NORMAL);
                else
                        canvas->SetMouseState(RAS_ICanvas::MOUSE_INVISIBLE);
+
+               // Setup vsync
+               int previous_vsync = canvas->GetSwapInterval();
+               if (startscene->gm.vsync == VSYNC_ADAPTIVE)
+                       canvas->SetSwapInterval(-1);
+               else
+                       canvas->SetSwapInterval(startscene->gm.vsync); // VSYNC_OFF == 0, VSYNC_ON == 1, so this works
+
                RAS_IRenderTools* rendertools = new KX_BlenderRenderTools();
                RAS_IRasterizer* rasterizer = NULL;
                //Don't use displaylists with VBOs
@@ -663,6 +671,7 @@ extern "C" void StartKetsjiShell(struct bContext *C, struct ARegion *ar, rcti *c
                }
                if (canvas)
                {
+                       canvas->SetSwapInterval(previous_vsync); // Set the swap interval back
                        delete canvas;
                        canvas = NULL;
                }
index 3bd1c02..3089b3f 100644 (file)
@@ -66,6 +66,16 @@ void KX_BlenderCanvas::SwapBuffers()
        BL_SwapBuffers(m_win);
 }
 
+void KX_BlenderCanvas::SetSwapInterval(int interval)
+{
+       BL_SetSwapInterval(m_win, interval);
+}
+
+int    KX_BlenderCanvas::GetSwapInterval()
+{
+       return BL_GetSwapInterval(m_win);
+}
+
 void KX_BlenderCanvas::ResizeWindow(int width, int height)
 {
        // Not implemented for the embedded player
index c201d86..c5318b8 100644 (file)
@@ -80,6 +80,16 @@ public:
                void 
        SwapBuffers(
        );
+
+               void
+       SetSwapInterval(
+               int interval
+       );
+
+               int
+       GetSwapInterval(
+       );
+
                void 
        ResizeWindow(
                int width,
index 6159899..6ed4866 100644 (file)
@@ -98,6 +98,16 @@ void BL_MakeDrawable(wmWindowManager *wm, wmWindow *win)
        wm_window_make_drawable(wm, win);
 }
 
+void BL_SetSwapInterval(struct wmWindow *win, int interval)
+{
+       wm_window_set_swap_interval(win, interval);
+}
+
+int BL_GetSwapInterval(struct wmWindow *win)
+{
+       return wm_window_get_swap_interval(win);
+}
+
 static void DisableForText()
 {
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); /* needed for texture fonts otherwise they render as wireframe */
index 54e76ff..8032d9a 100644 (file)
@@ -43,6 +43,8 @@ struct wmWindowManager;
 
 // special swapbuffers, that takes care of which area (viewport) needs to be swapped
 void   BL_SwapBuffers(struct wmWindow *win);
+void   BL_SetSwapInterval(struct wmWindow *win, int interval);
+int            BL_GetSwapInterval(struct wmWindow *win);
 
 void   BL_MakeDrawable(struct wmWindowManager *wm, struct wmWindow *win);
 
index bedee5d..6f7a878 100644 (file)
@@ -582,7 +582,12 @@ bool GPG_Application::initEngine(GHOST_IWindow* window, const int stereoMode)
                m_canvas = new GPG_Canvas(window);
                if (!m_canvas)
                        return false;
-                               
+
+               if (gm->vsync == VSYNC_ADAPTIVE)
+                       m_canvas->SetSwapInterval(-1);
+               else
+                       m_canvas->SetSwapInterval(gm->vsync); // VSYNC_OFF == 0, VSYNC_ON == 1, so this works
+
                m_canvas->Init();
                if (gm->flag & GAME_SHOW_MOUSE)
                        m_canvas->SetMouseState(RAS_ICanvas::MOUSE_NORMAL);
index a1d00da..e055938 100644 (file)
@@ -107,6 +107,20 @@ void GPG_Canvas::SwapBuffers()
        }
 }
 
+void GPG_Canvas::SetSwapInterval(int interval)
+{
+       if (m_window)
+               m_window->setSwapInterval(interval);
+}
+
+int GPG_Canvas::GetSwapInterval()
+{
+       if (m_window)
+               return m_window->getSwapInterval();
+
+       return 0;
+}
+
 void GPG_Canvas::ResizeWindow(int width, int height)
 {
        if (m_window->getState() == GHOST_kWindowStateFullScreen)
index 6168d96..6e1f86c 100644 (file)
@@ -55,6 +55,9 @@ public:
        virtual void SetMousePosition(int x, int y);
        virtual void SetMouseState(RAS_MouseState mousestate);
        virtual void SwapBuffers();
+       virtual void SetSwapInterval(int interval);
+       virtual int     GetSwapInterval();
+
        virtual int GetMouseX(int x) { return x; }
        virtual int GetMouseY(int y) { return y; }
        virtual float GetMouseNormalizedX(int x);
index 7845c11..e595f24 100644 (file)
@@ -1372,6 +1372,29 @@ static PyObject *gPyGetMipmapping(PyObject *)
        return PyLong_FromLong(gp_Rasterizer->GetMipmapping());
 }
 
+static PyObject *gPySetVsync(PyObject *, PyObject *args)
+{
+       int interval;
+
+       if (!PyArg_ParseTuple(args, "i:setVsync", &interval))
+               return NULL;
+
+       if (interval < VSYNC_OFF || interval > VSYNC_ADAPTIVE) {
+               PyErr_SetString(PyExc_ValueError, "Rasterizer.setVsync(value): value must be VSYNC_OFF, VSYNC_ON, or VSYNC_ADAPTIVE");
+               return NULL;
+       }
+
+       if (interval == VSYNC_ADAPTIVE)
+               interval = -1;
+       gp_Canvas->SetSwapInterval(interval);
+       Py_RETURN_NONE;
+}
+
+static PyObject *gPyGetVsync(PyObject *)
+{
+       return PyLong_FromLong(gp_Canvas->GetSwapInterval());
+}
+
 static struct PyMethodDef rasterizer_methods[] = {
        {"getWindowWidth",(PyCFunction) gPyGetWindowWidth,
         METH_VARARGS, "getWindowWidth doc"},
@@ -1417,6 +1440,8 @@ static struct PyMethodDef rasterizer_methods[] = {
        {"getFullScreen", (PyCFunction) gPyGetFullScreen, METH_NOARGS, ""},
        {"setMipmapping", (PyCFunction) gPySetMipmapping, METH_VARARGS, ""},
        {"getMipmapping", (PyCFunction) gPyGetMipmapping, METH_NOARGS, ""},
+       {"setVsync", (PyCFunction) gPySetVsync, METH_VARARGS, ""},
+       {"getVsync", (PyCFunction) gPyGetVsync, METH_NOARGS, ""},
        { NULL, (PyCFunction) NULL, 0, NULL }
 };
 
@@ -2189,6 +2214,11 @@ PyObject *initRasterizer(RAS_IRasterizer* rasty,RAS_ICanvas* canvas)
        KX_MACRO_addTypesToDict(d, RAS_MIPMAP_NEAREST, RAS_IRasterizer::RAS_MIPMAP_NEAREST);
        KX_MACRO_addTypesToDict(d, RAS_MIPMAP_LINEAR, RAS_IRasterizer::RAS_MIPMAP_LINEAR);
 
+       /* for get/setVsync */
+       KX_MACRO_addTypesToDict(d, VSYNC_OFF, VSYNC_OFF);
+       KX_MACRO_addTypesToDict(d, VSYNC_ON, VSYNC_ON);
+       KX_MACRO_addTypesToDict(d, VSYNC_ADAPTIVE, VSYNC_ADAPTIVE);
+
        // XXXX Add constants here
 
        // Check for errors
index 1b1e43a..9e8a6e8 100644 (file)
@@ -105,6 +105,17 @@ public:
                void 
        SwapBuffers(
        )=0;
+       
+       virtual
+               void
+       SetSwapInterval(
+               int interval
+       )=0;
+
+       virtual
+               int
+       GetSwapInterval(
+       )=0;
  
        virtual 
                void