cómo habilitar la sincronización vertical en OpenGL?

Question

¿Cómo habilita la sincronización vertical?

¿Es algo tan sencillo como glEnable(GL_VSYNC)? (aunque no hay nada como GL_VSYNC ni nada parecido en las opciones que glEnable acepta).

o no hay ninguna forma estándar de hacer esto en OpenGL?

Answer 1

En Windows existe método de extensión de OpenGL wglSwapIntervalEXT.
Desde el puesto de b2b3 http://www.gamedev.net/community/forums/topic.asp?topic_id=360862:

---- ----- cita comienza

Si está trabajando en Windows usted tiene que utilizar las extensiones de utilizar la función wglSwapIntervalEXT. Es definido en wglext.h. También querrá descargar el archivo glext.h. En el archivo de wglext, todos los puntos de entrada para las extensiones específicas de Windows son declarados. Todas estas funciones comienzan en con el prefijo wgl. Para obtener más información sobre todas las extensiones publicados se puede mirar en registro de extensiones de OpenGL.

wglSwapIntervalEXT es de WGL_EXT_swap_control extensión. Es le permite especificar el número mínimo de cuadros antes de cada intercambio de memoria intermedia. Por lo general, se utiliza para la sincronización vertical de (si se establece de intercambio intervalo de 1). Puede encontrar más información sobre la extensión completa de aquí. Antes de usar esta función necesita consulta si su tarjeta tiene soporte para para WGL_EXT_swap_control y luego obtenga el puntero a la función usando la función wglGetProcAddress.

para la prueba de apoyo de extensión dada puede utilizar la función de esta manera:

#include <windows.h> 
#include "wglext.h" 

bool WGLExtensionSupported(const char *extension_name) 
{ 
    // this is pointer to function which returns pointer to string with list of all wgl extensions 
    PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglGetExtensionsStringEXT = NULL; 

    // determine pointer to wglGetExtensionsStringEXT function 
    _wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC) wglGetProcAddress("wglGetExtensionsStringEXT"); 

    if (strstr(_wglGetExtensionsString(), extension_name) == NULL) 
    { 
     // string was not found 
     return false; 
    } 

    // extension is supported 
    return true; 
} 

para inicializar su punteros de función es necesario:

PFNWGLSWAPINTERVALEXTPROC  wglSwapIntervalEXT = NULL; 
PFNWGLGETSWAPINTERVALEXTPROC wglGetSwapIntervalEXT = NULL; 

if (WGLExtensionSupported("WGL_EXT_swap_control")) 
{ 
    // Extension is supported, init pointers. 
    wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) LogGetProcAddress("wglSwapIntervalEXT"); 

    // this is another function from WGL_EXT_swap_control extension 
    wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC) LogGetProcAddress("wglGetSwapIntervalEXT"); 
} 

Entonces puede usar estos punteros como cualquier otro puntero para funcionar. Para habilitar vync puede llamar a wglSwapIntervalEXT (1), para deshabilitarlo llame a wglSwapIntervalEXT (0).

Para obtener el intervalo de intercambio actual necesita llamar wglGetSwapIntervalEXT().

---- ----- cita termina

Answer 2

Se resume en el wiki de OpenGL, aquí: http://www.opengl.org/wiki/Swap_Interval

Answer 3

caso WGL se describe en el answer by eugensk00.

Para CGL (MacOSX) consulte this answer para otra pregunta de SO.

Para EGL hay eglSwapInterval() función, pero al parecer (ver this y this) no garantiza resultado sin desgarramiento - sólo espera período determinado (tal vez es sólo debido a la rotura de los conductores).

Para GLX (Linux con X11 etc.) hay al menos 3 extensiones similares para esto, con un grado de funcionalidad variable. La wiki de OpenGL actualmente solo muestra una, que no está soportada por Mesa < = 10.5.9 (y tal vez más). He aquí una lista de más extensión completa de funciones (que aparece en OpenGL wiki) al menos:

1. GLX_EXT_swap_control

   • Conjunto intervalo de intercambio por embutición por pantalla: glXSwapIntervalEXT(dpy, drawable, interval)

   • Obtenga el intervalo de intercambio actual: glXQueryDrawable(dpy, drawable, GLX_SWAP_INTERVAL_EXT, &interval)

   • Obtenga el intervalo de intercambio máximo: glXQueryDrawable(dpy, drawable, GLX_MAX_SWAP_INTERVAL_EXT, &maxInterval)

   • Desactivar Vsync: Conjunto interval a 0

2. GLX_MESA_swap_control

   • Conjunto intervalo de intercambio por contexto: glXSwapIntervalMESA(interval)

   • Obtener intervalo de intercambio actual: glXGetSwapIntervalMESA()

   • obtener el máximo intervalo de swap: no soportado

   • Disable Vsync: juego de interval a 0

3. GLX_SGI_swap_control

   • Set intervalo swap: glXSwapIntervalSGI(interval).

   • Obtener intervalo de intercambio actual: no soportado

   • Obtener intervalo máximo swap: no soportado

   • Disable Vsync: no soportado (interval==0 es un error)

Para Vsync adaptativa, ver OpenGL wiki.