IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

OpenGL Discussion :

Synchronisation verticale portable


Sujet :

OpenGL

  1. #1
    Membre confirmé
    Avatar de Le Farfadet Spatial
    Homme Profil pro
    En cours de précision…
    Inscrit en
    Avril 2008
    Messages
    186
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : En cours de précision…

    Informations forums :
    Inscription : Avril 2008
    Messages : 186
    Points : 604
    Points
    604
    Par défaut Synchronisation verticale portable
    Salut à tous !

    A priori, je suis moins demandeur que la plupart de ceux qui fréquentent cette partie du forum concernant OpenGL, dans la mesure où je fais de la « visualisation scientifique » : je ne cherche pas des frags de folie. Pourtant, j’ai fini par mettre en évidence un problème de tearing. Je précise que j’utilise déjà un double tampon.

    Pour en venir à bout, il me faut réaliser une synchronisation verticale avec l’écran. la documentation d’OpenGL explique très bien pourquoi c’est dépendant du système.

    Très bien. Au-delà de cela, sachant que je dois réaliser des applications qui fonctionnent aussi bien avec X Windows que Wayland, mais aussi sous MacOS X et Microsoft Windows, je suis un peu perdu. J’ai trouvé de la documentation dans tous les sens sur le web, mais pas très claire et parfois contradictoire, sachant que je ne suis pas totalement en mesure de tester sur absolument toutes les plateformes…

    Donc, je voulais savoir si quelqu’un a des exemples de synchronisation verticale portable dont je pourrais m’inspirer.

    À bientôt.

    Le Farfadet Spatial

  2. #2
    Membre confirmé
    Avatar de Le Farfadet Spatial
    Homme Profil pro
    En cours de précision…
    Inscrit en
    Avril 2008
    Messages
    186
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : En cours de précision…

    Informations forums :
    Inscription : Avril 2008
    Messages : 186
    Points : 604
    Points
    604
    Par défaut
    Salut à tous !

    Plutôt que de vouloir immédiatement faire quelque chose de portable, je tente déjà de faire quelque chose qui fonctionne chez moi (première étape sans doute pas inutile). Justement, ça ne colle pas. Je code sous Debian GNU/Linux Wheezy.

    J’ai ajouté l’en-tête de GLX :

    Puis, au cours de l’initialisation d’OpenGL, j’ai ajouté la synchronisation verticale :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    glXSwapIntervalMESA(1);
    La compilation en elle-même aboutit, ce qui semble indiquer que le compilateur trouve le prototype de « glXSwapIntervalMESA ». En revanche, l’édition des liens échoue avec le message suivant :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    /home/yoann/program/C++/opengl/nehe/tutoriel4/src/fenetre.cpp:73: undefined reference to `glXSwapIntervalMESA'
    Il ne trouve pas la fonction, comme si j’avais oublié de lier une bibliothèque. Je crois pourtant avoir fait ce qu’il faut, voici le fichier « CMakeLists.txt » de mon projet :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    ## Génération des tutoriels OpenGL de NeHe version Gtkmm.
     
    cmake_minimum_required(VERSION 2.6)
     
    project(Tutoriel4)
     
    # Répertoire où placer l’exécutable.
    set(EXECUTABLE_OUTPUT_PATH bin/${CMAKE_BUILD_TYPE})
    # Nom de l’exécutable.
    set(EXECUTABLE_NAME tutoriel4)
     
    find_package(X11)
    find_package(OpenGL REQUIRED)
     
    find_package(PkgConfig REQUIRED)
     
    pkg_check_modules(Glibmm glibmm-2.4>=2.4.0)
    pkg_check_modules(GTKmm gtkmm-2.4>=2.4.0)
    pkg_check_modules(GLExtmm gtkglextmm-1.2>=1.2.0)
     
    link_directories(
            ${X11_LIBRARY_DIRS}
            ${OPENGL_LIBRARY_DIRS}
            ${Glibmm_LIBRARY_DIRS}
            ${GTKmm_LIBRARY_DIRS}
            ${GLExtmm_LIBRARY_DIRS}
    )
    include_directories(
            ${X11_INCLUDE_DIRS}
            ${OPENGL_INCLUDE_DIRS}
            ${Glibmm_INCLUDE_DIRS}
            ${GTKmm_INCLUDE_DIRS}
            ${GLExtmm_INCLUDE_DIRS}
    )
     
    file(
            GLOB_RECURSE
            source_files
            src/*
    )
     
    add_executable(
            ${EXECUTABLE_NAME}
            ${source_files}
    )
     
    target_link_libraries(
            ${EXECUTABLE_NAME}
            ${X11_LIBRARIES}
            ${OPENGL_LIBRARIES}
            ${Glibmm_LIBRARIES}
            ${GTKmm_LIBRARIES}
            ${GLExtmm_LIBRARIES}
    )
    Quelqu’un a-t-il une idée de ce que j’ai oublié ?

    À bientôt.

    Le Farfadet Spatial

  3. #3
    Membre confirmé
    Avatar de Le Farfadet Spatial
    Homme Profil pro
    En cours de précision…
    Inscrit en
    Avril 2008
    Messages
    186
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : En cours de précision…

    Informations forums :
    Inscription : Avril 2008
    Messages : 186
    Points : 604
    Points
    604
    Par défaut
    Salut à tous !

    Finalement, en réalisant un savant mélange d’une entrée de bitSphere et d’une autre de OpenFramework, j’en suis arrivé à un résultat qui semble fonctionner. En tout cas, sous Linux, cela fait ce que je veux. Je suis intéressé pour que des personnes fassent le test sous MacOS X (je devrais pouvoir le faire sous peu dans peu de temps) et sous Microsoft Windows (je ne pourrais pas m’en charger).

    J’ai donc réalisé le bout de code suivant :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    #include <stdlib.h>
    #include <GL/gl.h>
    #include <GL/glu.h>
    #include <string.h>
    #include <stdio.h>
     
    #ifdef WIN32
    #include <GL/glext.h>
    #elifdef APPLE
    #include <CGLCurrent.h>
    #include <CGLTypes.h>
    #include <OpenGL.h>
    #else
    #include <GL/glx.h>
    #endif  /* #ifdef WIN32 */
     
    /*
        Search for extName in the extensions string.  Use of strstr()
        is not sufficient because extension names can be prefixes of
        other extension names.  Could use strtok() but the constant
        string returned by glGetString can be in read-only memory.
     */
    bool checkGLXExtension (const char* extName) {
      /* Liste des extensions GLX disponibles. */
      char* list = (char*) glXQueryExtensionsString(dpy, screen);
      /* Chaîne décrivant les extensions GLX. */
      char* end;
      /* Taille de la chaîne décrivant l'extension recherchée. */
      int extNameLen;
     
      extNameLen = strlen(extName);
      end = list + strlen(list);
     
      while (list < end) {
        /* Nombre d'extensions disponibles. */
        int n = strcspn(list, " ");
     
        if ((extNameLen == n) && (strncmp(extName, list, n) == 0))
          return true;
     
        list += (n + 1);
      }
     
      return false;
    }
     
    /*
     * Active ou désactive la synchronisation verticale.
     * bSync : Faut-il, oui ou non, activer la synchronisation verticale ?
     */
    void setVerticalSync (bool bSync) {
    #ifdef WIN32
      if (bSync) {
        if (GLEE_WGL_EXT_swap_control) wglSwapIntervalEXT (1);
      }
      else {
        if (GLEE_WGL_EXT_swap_control) wglSwapIntervalEXT (0);
      }
    #elifdef APPLE
      /* Valeur de synchronisation. */
      long sync = (bSync == true)? 1: 0;  
      CGLSetParameter (CGLGetCurrentContext(), kCGLCPSwapInterval, &sync);  
    #else
      /* Intervalle de synchronisation. */
      const GLint intervalle = (bSync)? 2: 0;
     
      /* Fonction pour la synchronisation. */
      GLvoid (*swapInterval)(GLint);
      if (checkGLXExtension("GLX_MESA_swap_control")) {
        swapInterval =
    (GLvoid (*)(GLint)) glXGetProcAddress((const GLubyte*) "glXSwapIntervalMESA");
      }
      else if (checkGLXExtension("GLX_SGI_swap_control")) {
        swapInterval =
    (GLvoid (*)(GLint)) glXGetProcAddress((const GLubyte*) "glXSwapIntervalSGI");
      }
      else {
        printf("Impossible de réaliser une synchronisation verticale.\n");
      }
     
      swapInterval(intervalle);
    #endif  /* #ifdef WIN32 */
    }
    Dans la procédure « checkGLXExtension », à la ligne « char* list = (char*) glXQueryExtensionsString(dpy, screen); », il faut remplacer « dpy » par votre connexion au serveur X et « screen » par le numéro de l’écran à synchroniser (voir la documentation de « glXQueryExtensionsString »). L’entrée OpenFramework que j’ai donnée plus haut indique comment le faire avec Gdk.

    À partir de là, il suffit d’utiliser « setVerticalSync(true); » pour activer la synchronisation verticale et « setVerticalSync(false); » pour l’arrêter.

    Je passe le sujet en résolu, mais dites moi si cela a fonctionné chez vous.

    À bientôt.

    Le Farfadet Spatial

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [2D/3D] OpenGL et synchronisation verticale
    Par zenux dans le forum Qt
    Réponses: 2
    Dernier message: 08/10/2013, 21h13
  2. SDL et synchronisation verticale
    Par Frifron dans le forum SDL
    Réponses: 1
    Dernier message: 08/08/2008, 10h26
  3. [Portable] Bandes verticales sur l'ecran
    Par luc2verga dans le forum Ordinateurs
    Réponses: 3
    Dernier message: 15/07/2008, 20h01
  4. Réponses: 1
    Dernier message: 27/09/2007, 11h45
  5. Synchronisation verticale
    Par hs_dino dans le forum OpenGL
    Réponses: 2
    Dernier message: 28/09/2003, 10h35

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo