QGLWidget

La classe QGLWidget est un widget pour afficher des graphismes avec OpenGL. Plus d'informations...

#include <QGLWidget>

Voir la position dans l'arbre des classes.

Héritage

Hérite de QWidget.

Description détaillée

La classe QGLWidget est un widget pour afficher des graphismes avec OpenGL.

QGLWidget fournit des fonctionnalités pour afficher des graphismes OpenGL dans une application Qt. La classe est très simple à utiliser. On hérite à partir de QGLWidget et on utilise la sous-classe comme n'importe quelle QWidget, sauf que l'on a maintenant le choix entre utiliser QPainter ou les commandes de rendu OpenGL.

QGLWidget fournit trois fonctions virtuelles de commodité que l'on peut réimplémenter dans la sous-classe pour effectuer les tâches basiques d'OpenGL :

• paintGL() - Affiche la scène OpenGL. Est appelé à chaque fois que le widget a besoin d'être mis à jour.
• resizeGL() - Définit la vue OpenGL, la matrice de projection, etc. Est appelé à chaque fois que le widget est redimensionné (et aussi lorsque le widget est affiché pour la première fois comme tout nouveau widget qui reçoit automatiquement un événement de redimensionnement).
• initializeGL() - Définit le contexte de rendu OpenGL, crée les listes d'affichage, etc. Est appelé une seule fois avant que resizeGL() ou paintGL() ne soit appelé.

Une sous-classe de QGLWidget pourrait ressembler à l'ébauche suivante :

 class MyGLDrawer : public QGLWidget
 {
     Q_OBJECT        // On doit inclure ceci si on utilise les signaux/slots de Qt
 
 public:
     MyGLDrawer(QWidget *parent)
         : QGLWidget(parent) {}
 
 protected:
 
     void initializeGL()
     {
         // Définit le contexte de rendu, les listes d'affichages, etc. :
         ...
         glClearColor(0.0, 0.0, 0.0, 0.0);
         glEnable(GL_DEPTH_TEST);
         ...
     }
 
     void resizeGL(int w, int h)
     {
         // Met en place la vue, la projection, etc. :
         glViewport(0, 0, (GLint)w, (GLint)h);
         ...
         glFrustum(...);
         ...
     }
 
     void paintGL()
     {
         // Dessine la scène :
         ...
         glRotatef(...);
         glMaterialfv(...);
         glBegin(GL_QUADS);
         glVertex3f(...);
         glVertex3f(...);
         ...
         glEnd();
         ...
     }
 
 };

Si on veut forcer le réaffichage à partir d'autres endroits que paintGL() (un exemple ordinaire est d'utiliser les timers pour les scènes animées), on doit appeler la fonction updateGL() du widget.

Le contexte de rendu OpenGL du widget est le contexte courant lorsque paintGL(), resizeGL() ou initializeGL() sont appelés. Si on doit appeler les fonctions standards de la bibliothèque OpenGL depuis d'autres endroits (par exemple, depuis le constructeur de votre widget ou depuis vos propres fonctions de dessin), on doit appeler d'abord makeCurrent().

QGLWidget fournit des fonctions pour demander un nouveau format d'affichage et il est même possible de créer des widgets avec des contextes d'affichage personnalisés.

On peut aussi partager les listes d'affichage OpenGL entre les objets QGLWidget (voir la documentation des constructeurs de QGLWidget pour les détails).

On note que sous Windows, le QGLContext appartenant à un QGLWidget doit être recréé lorsque le QGLWidget obtient un nouveau parent. Cela est nécessaire à cause des limitations des plateformes Windows. Cela peut poser des problèmes aux utilisateurs qui ont hérité et installé leur propre QGLContext sur un QGLWidget. Il est possible de contourner ce problème en insérant le QGLWidget dans un widget fictif, et de donner à ce widget fictif un nouveau parent, au lieu de le faire sur le QGLWidget. Cela va contourner complètement le problème et c'est ce qui est recommandé aux utilisateurs nécessitant ce genre de fonctionnalités.

Sur Mac OS X, lorsque Qt est construit avec le support Cocoa, un QGLWidget ne peut pas avoir de widget frère placé au-dessus de lui. Ceci est dû à une limitation de la bibliothèque Cocoa et n'est pas pris en charge par Apple.

Calques

Le QGLWidget crée un calque OpenGL en plus du contexte normal si les calques sont supportés par le système hôte.

Si vous souhaitez utiliser les calques, vous devez le spécifier dans le format (à noter : l'utilisation des calques doit être demandée dans le format passé au constructeur de QGLWidget). Le widget OpenGL doit aussi implémenter une ou plusieurs de ces méthodes virtuelles :

• paintOverlayGL()
• resizeOverlayGL()
• initializeOverlayGL()

Ces méthodes fonctionnent de la même manière que les fonctions équivalentes paintGL() etc., sauf qu'elles seront appelées lorsque le contexte du calque est rendu courant. On peut explicitement rendre le contexte du calque courant en utilisant makeOverlayCurrent() et on peut accéder au contexte du calque directement (par exemple, pour connaître sa couleur de transparence) en appelant overlayContext().

Sur les serveurs X sur lesquels la vue par défaut est un calque, les fenêtres Qt non-OpenGL peuvent aussi être utilisées comme calques.

Techniques de dessin

Comme décrit précédemment, on hérite de QGLWidget pour dessiner du contenu 3D de la façon suivante :

• On réimplémente les fonctions QGLWidget::initializeGL() et QGLWidget::resizeGL() pour définir l'état d'OpenGL et pour fournir les transformations de perspective.
• On réimplémente QGLWidget::paintGL() pour dessiner la scène 3D, en appelant seulement des fonctions OpenGL pour dessiner dans le widget.

Il est aussi possible de dessiner des graphismes 2D au-dessus d'une sous-classe de QGLWidget. Pour cela il est nécessaire de réimplémenter la fonction QGLWidget::paintEvent() et de :

• construire un objet QPainter ;
• l'initialiser pour l'utiliser sur le widget avec la fonction QPainter::begin() ;
• dessiner les primitives avec les fonctions de QPainter ;
• appeler QPainter::end() pour conclure le dessin.

Dessiner du contenu 2D au-dessus de contenu 3D demande un petit effort supplémentaire. Une des approches pour le faire est présentée dans l'exemple overpainting.

Parallélisation

Il est possible de dessiner dans un QGLWidget à partir d'un autre thread, mais cela demande que tous les accès au contexte OpenGL soient sécurisés. Le thread de l'IHM Qt va essayer d'utiliser le contexte dans resizeEvent et dans paintEvent, donc afin de paralléliser le dessin en utilisant un widget OpenGL, ces fonctions doivent être interceptées dans le thread de l'IHM et prises en charge dans l'application.

OpenGL est une marque déposée de Silicon Graphics, Inc. aux États-Unis et dans les autres pays.

Voir aussi QGLPixelBuffer, l'exemple Hello GL, l'exemple 2D Painting, l'exemple Overpainting et l'exemple Grabber.

Fonctions membres

QGLWidget::QGLWidget ( QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WindowFlags f = 0 )

Construit un widget OpenGL avec le widget parent.

Le format par défaut est utilisé. Le widget va être invalide si le système ne prend pas en charge OpenGL.

Les paramètres parent et les drapeaux du widget f sont passés au constructeur du QWidget.

Si shareWidget est un QGLWidget valide, ce widget va partager les listes d'affichage et les objets textures d'OpenGL avec le widget shareWidget. Mais si shareWidget et ce widget ont un format différent, le partage peut ne pas être possible. On peut vérifier si le partage est activé avec isSharing().

L'initialisation de l'état de rendu d'OpenGL, etc. devrait être faite en surchargeant la fonction initializeGL(), plutôt que dans le constructeur de la sous-classe de QGLWidget.

Voir aussi QGLFormat::defaultFormat() et l'exemple Textures.

QGLWidget::QGLWidget ( QGLContext * context, QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WindowFlags f = 0 )

Construit un widget OpenGL avec le widget parent.

Le contexte context est un pointeur sur un QGLContext que l'on souhaite attacher à ce widget. Cela permet de passer sa propre sous-classe QGLContext.

Le widget va être invalide si le système ne prend pas en charge OpenGL.

Les paramètres parent et les drapeaux du widget f sont passés au constructeur du QWidget.

Si shareWidget est un QGLWidget valide, ce widget va partager les listes d'affichage et les objets textures d'OpenGL avec le widget shareWidget. Mais si shareWidget et ce widget ont un format différent, le partage peut ne pas être possible. On peut vérifier si le partage est activé avec isSharing().

L'initialisation de l'état de rendu d'OpenGL, etc. devrait être faite en surchargeant la fonction initializeGL(), plutôt que dans le constructeur de la sous-classe de QGLWidget.

Voir aussi QGLFormat::defaultFormat() et isValid().

QGLWidget::QGLWidget ( const QGLFormat & format, QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WindowFlags f = 0 )

Construit un widget OpenGL avec le widget parent.

Le paramètre format indique les options de rendu désirées. Si le système OpenGL/de fenêtrage hôte ne peut pas satisfaire toutes les caractéristiques demandées du format, la plus proche configuration va être utilisée. Après la création, la méthode format() va retourner le format actuel obtenu.

Le widget va être invalide si le système ne prend pas en charge OpenGL.

Les paramètres parent et les drapeaux de widget f sont passés au constructeur du QWidget.

Si shareWidget est un QGLWidget valide, ce widget va partager les listes d'affichage et les objets textures d'OpenGL avec le widget shareWidget. Mais si shareWidget et ce widget ont un format différent, le partage peut ne pas être possible. On peut vérifier si le partage est activé avec isSharing().

L'initialisation de l'état de rendu d'OpenGL, etc. devrait être faite en surchargeant la fonction initializeGL(), plutôt que dans le constructeur de la sous-classe de QGLWidget.

Voir aussi QGLFormat::defaultFormat() et isValid().

QGLWidget::~QGLWidget ()

Détruit le widget.

bool QGLWidget::autoBufferSwap () const [protected]

Retourne true si le widget effectue automatiquement l'échange de buffers OpenGL ; sinon retourne false.

Voir aussi setAutoBufferSwap().

GLuint QGLWidget::bindTexture ( const QImage & image, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA )

Appelle QGLContext::bindTexture(image, target, format) avec le contexte courant.

Voir aussi deleteTexture().

GLuint QGLWidget::bindTexture ( const QPixmap & pixmap, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA )

Appelle QGLContext::bindTexture(pixmap, target, format) avec le contexte courant.

Voir aussi deleteTexture().

GLuint QGLWidget::bindTexture ( const QImage & image, GLenum target, GLint format, QGLContext::BindOptions options )

Il s'agit d'une fonction surchargée.

Les options de liaisons sont un ensemble d'options permettant de décider comment attacher la texture au contexte.

Cette fonction a été introduite dans Qt 4.6.

GLuint QGLWidget::bindTexture ( const QPixmap & pixmap, GLenum target, GLint format, QGLContext::BindOptions options )

Il s'agit d'une fonction surchargée.

Génère et attache, à partir de pixmap, une texture OpenGL 2D au contexte courant. L'identifiant de la texture générée est retourné et peut être utilisé.

Les options de liaisons sont un ensemble d'options permettant de décider comment attacher la texture au contexte.

Cette fonction a été introduite dans Qt 4.6.

GLuint QGLWidget::bindTexture ( const QString & fileName )

Il s'agit d'une fonction surchargée.

Appelle QGLContext::bindTexture(fileName) avec le contexte courant.

Voir aussi deleteTexture().

const QGLColormap & QGLWidget::colormap () const

Retourne la palette de couleurs pour ce widget.

Habituellement, seulement les widgets supérieurs peuvent avoir différentes palettes de couleurs installées. La demande de la palette d'un widget enfant va renvoyer la palette du widget au-dessus de celui-ci.

Si aucune palette n'a été définie pour ce widget, le QGLColormap retourné va être vide.

Voir aussi setColormap() et QGLColormap::isEmpty().

const QGLContext * QGLWidget::context () const

Retourne le contexte de ce widget.

Il est possible que le contexte ne soit pas valide (voir isValid()), par exemple, si le matériel hôte ne supporte pas les attributs de format qui ont été démandés.

QImage QGLWidget::convertToGLFormat ( const QImage & img ) [static]

Convertit l'image img dans le format anonyme attendu par les fonctions OpenGL tel que glTexImage2D(). L'image retournée n'est pas utilisable comme une QImage mais QImage::width(), QImage::height() et QImage::bits() peuvent être utilisés avec OpenGL. Le format OpenGL utilisé est GL_RGBA.

void QGLWidget::deleteTexture ( GLuint id )

Appelle QGLContext::deleteTexture(id) avec le contexte courant.

Voir aussi bindTexture().

void QGLWidget::doneCurrent ()

Déclare un non-contexte OpenGL comme contexte courant. Normalement, on n'a pas besoin d'appeler cette fonction ; QGLContext l'appelle si nécessaire. Toutefois, la fonction peut être utile dans les environnements multithreads.

bool QGLWidget::doubleBuffer () const

Retourne true si le contexte de rendu OpenGL possède le double buffering ; sinon retourne false.

Voir aussi QGLFormat::doubleBuffer().

void QGLWidget::drawTexture ( const QRectF & target, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D )

Appelle la fonction correspondante QGLContext::drawTexture() avec les paramètres target, textureId et textureTarget pour le contexte courant du widget.

Cette fonction a été introduite dans Qt 4.4.

void QGLWidget::drawTexture ( const QPointF & point, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D )

Appelle la fonction correspondante QGLContext::drawTexture() avec les paramètres point, textureId et textureTarget pour le contexte courant du widget.

Cette fonction a été introduite dans Qt 4.4.

bool QGLWidget::event ( QEvent * e ) [virtual protected]

Réimplémentation de QObject::event().

QGLFormat QGLWidget::format () const

Retourne le format du contexte de rendu OpenGL contenu.

Voir aussi setFormat().

void QGLWidget::glDraw () [virtual protected]

Exécute la fonction virtuelle paintGL().

Le contexte de rendu du widget va devenir le contexte courant et initializeGL() va être appelé si cela n'a pas déjà été fait.

void QGLWidget::glInit () [virtual protected]

Initialise OpenGL pour le contexte du widget. Appelle la fonction virtuelle initializeGL().

QImage QGLWidget::grabFrameBuffer ( bool withAlpha = false )

Retourne une image du frame buffer. Si le paramètre withAlpha est défini à true, le canal alpha est inclus.

Selon le matériel, on peut sélectionner explicitement le buffer de couleur à capturer avec un appel à glReadBuffer() avant cette fonction.

void QGLWidget::initializeGL () [virtual protected]

Cette fonction virtuelle est appelée une seule fois avant le premier appel à paintGL() ou à resizeGL() et chaque fois qu'un nouveau QGLContext est assigné au widget. À réimplementer dans une sous-classe.

Cette fonction devrait mettre en place tous les drapeaux de rendu de contexte OpenGL, définir les listes d'affichage, etc.

Il n'y a pas besoin d'appeler makeCurrent() car cela est déjà fait lorsque cette fonction est appelée.

void QGLWidget::initializeOverlayGL () [virtual protected]

Cette fonction virtuelle s'utilise de la même manière que initializeGL() mais agit sur le calque du widget à place du contexte principal. Cela signifie que ce initializeOverlayGL() est appelé une seule fois avant le premier appel à paintOverlayGL() ou resizeOverlayGL(). À réimplementer dans une sous-classe.

Cette fonction devrait mettre en place tous les drapeaux de rendu de contexte OpenGL, définir les listes d'affichage, etc.

Il n'y a pas besoin d'appeler makeOverlayCurrent() car cela est déjà fait lorsque cette fonction est appelée.

bool QGLWidget::isSharing () const

Retourne true si le contexte OpenGL de ce widget est partagé avec un autre contexte OpenGL, sinon retourne false. Le partage des contextes peut ne pas être possible si les widgets utilisent différents formats.

Voir aussi format().

bool QGLWidget::isValid () const

Retourne true si le widget a un contexte de rendu OpenGL valide ; sinon retourne false. Un widget devient invalide si le système ne prend pas en charge OpenGL.

void QGLWidget::makeCurrent ()

Définit ce widget comme le widget courant pour les opérations OpenGL, c'est-à-dire que le contexte de rendu OpenGL de ce widget est le contexte de rendu courant.

void QGLWidget::makeOverlayCurrent ()

Définit le contexte du calque de ce widget courant. On utilise cette fonction si on a besoin d'exécuter des commandes OpenGL sur le calque en dehors des fonctions initializeOverlayGL(), resizeOverlayGL() et paintOverlayGL().

N'a aucun effet si le widget n'a pas de calque.

Voir aussi makeCurrent().

const QGLContext * QGLWidget::overlayContext () const

Retourne le contexte du calque de ce widget, ou 0 si le widget n'a pas de calque.

Voir aussi context().

void QGLWidget::paintEvent ( QPaintEvent * event ) [virtual protected]

Réimplementation de QWidget::paintEvent().

Manipule les événements de dessin passés dans le paramètre event. Appelle la fonction virtuelle paintGL().

Le contexte de rendu du widget va devenir le contexte courant et initializeGL() va être appelé si cela n'a jamais été fait.

void QGLWidget::paintGL () [virtual protected]

Cette fonction virtuelle est appelée à chaque fois que le widget doit être redessiné. À réimplementer dans une sous-classe.

Il n'y a pas besoin d'appeler makeCurrent() car cela est fait lorsque cette fonction est appelée.

void QGLWidget::paintOverlayGL () [virtual protected]

Cette fonction virtuelle s'utilise de la même manière que paintGL() mais agit sur le contexte du calque du widget à la place du contexte principal du widget. Cela signifie que paintOverlayGL() est appelé à chaque fois que le calque du widget doit être redessiner. À réimplementer dans une sous-classe.

Il n'y a pas besoin d'appeler makeOverlayCurrent() car cela est fait lorsque cette fonction est appelée.

void QGLWidget::qglClearColor ( const QColor & c ) const

Fonction de commodité pour spécifier une couleur d'effacement à OpenGL. Appelle glClearColor (dans le mode RGBA) ou glClearIndex (dans le mode indexé) avec la couleur cc. La fonction s'applique au contexte OpenGL de ce widget.

Voir aussi qglColor(), QGLContext::currentContext() et QColor.

void QGLWidget::qglColor ( const QColor & c ) const

Fonction de commodité pour spécifier une couleur pour le dessin à OpenGL. Appelle glColor4 (dans le mode RGBA) ou glIndex (dans le mode indexé) avec la couleur c. La fonction interagit avec le contexte OpenGL de ce widget.

Note : cette fonction n'est pas prise en charge sur les systèmes OpenGL/ES 2.0.

Voir aussi qglClearColor(), QGLContext::currentContext() et QColor.

QPixmap QGLWidget::renderPixmap ( int w = 0, int h = 0, bool useContext = false )

Dessine la scène courante dans un pixmap et renvoie le pixmap.

On peut utiliser cette méthode sur les objets QGLWidget visibles et invisibles.

Cette méthode va créer un pixmap et un QGLContext temporaire pour dessiner sur le pixmap. Elle va alors appeler initializeGL(), resizeGL() et paintGL() sur ce contexte. Finalement, le contexte original du widget est restauré.

La taille du pixmap va être w pixels de large et h pixels de haut à moins que l'un de ces paramètres ne soit 0 (la valeur par défaut), dans ce cas le pixmap aura la même taille que le widget.

Si useContext est true, la méthode va essayer d'être plus efficace en utilisant le contexte OpenGL existant pour dessiner le pixmap. La valeur par défaut est false. On utilise true seulement si on comprend le risque. À noter que sous Windows un contexte temporaire doit être créé et que l'utilisation du paramètre useContext n'est pas prise en charge.

Les calques ne sont pas rendus sur le pixmap.

Si le contexte de rendu OpenGL et le bureau ont des profondeurs de bits différentes, le résultat va surement être surprenant.

À noter que la création de listes d'affichage, les modifications de la matrice de vue, etc. devraient être effectuées dans initializeGL(). Si cela n'est pas fait, le QGLContext temporaire ne va pas être initialisé correctement et le rendu du pixmap peut être incomplet ou corrompu.

void QGLWidget::renderText ( int x, int y, const QString & str, const QFont & font = QFont(), int listBase = 2000 )

Dessine la chaîne de caractères str dans le contexte OpenGL de ce widget.

x et y sont dans l'espace de coordonnées de la fenêtre, avec pour origine le coin supérieur gauche de la fenêtre. Si le paramètre font n'est pas indiqué, la police actuellement définie va être utilisée pour dessiner la chaîne de caractères. Pour changer la couleur de rendu du texte, on peut utiliser la fonction glColor() (ou la fonction de commodité qglColor()), avant l'appel à renderText().

Le paramètre listBase est obsolète et va être retiré dans une prochaine version de Qt.

Note : cette fonction efface le stencil buffer.

Note : cette fonction n'est pas prise en charge sur les systèmes OpenGL/ES.

Note : cette fonction désactive temporairement le test de profondeur lors du dessin du texte.

Note : cette fonction peut seulement être utilisée dans un bloc QPainter::beginNativePainting()/QPainter::endNativePainting() si le moteur de rendu par défaut est QPaintEngine::OpenGL. Pour définir QPaintEngine::OpenGL comme moteur de rendu par défaut, on appelle QGL::setPreferredPaintEngine(QPaintEngine::OpenGL) avant le constructeur de la QApplication.

On dessine au-dessus avec la fonction QPainter::drawText() à la place.

void QGLWidget::renderText ( double x, double y, double z, const QString & str, const QFont & font = QFont(), int listBase = 2000 )

Il s'agit d'une fonction surchargée.

x, y et z sont dans l'espace de coordonnées de la scène ou des objets selon les matrices de projection et de modèle actuellement en place. Cela peut être utile si on souhaite annoter des modèles avec du texte et avoir le texte qui se déplace avec le modèle comme s'ils étaient tournés, etc.

Note : cette fonction n'est pas prise en charge sur les systèmes OpenGL/ES.

Note : si le test de profondeur est activé avant l'appel de la fonction, alors le texte dessiné va passer le test de profondeur contre les modèles déjà dessinés dans la scène. On utilise glDisable(GL_DEPTH_TEST) avant l'appel de la fonction pour annoter les modèles sans le test de profondeur pour le texte.

On dessine au-dessus avec la fonction QPainter::drawText() à la place.

void QGLWidget::resizeEvent ( QResizeEvent * event ) [virtual protected]

Réimplémentation de QWidget::resizeEvent().

Gère les événements de redimensionnement qui sont passés dans le paramètre event. Appelle la fonction virtuelle resizeGL().

void QGLWidget::resizeGL ( int width, int height ) [virtual protected]

Cette fonction virtuelle est appelée à chaque fois que le widget est redimensionné. La nouvelle taille est passée dans les paramètres width et height pour la largeur et la hauteur respectivement. À réimplementer dans une sous-classe.

Il n'y a pas besoin d'appeler makeCurrent() car cela a déjà été effectué avant l'appel de cette fonction.

void QGLWidget::resizeOverlayGL ( int width, int height ) [virtual protected]

Cette fonction virtuelle s'utilise de la même façon que paintGL() sauf qu'elle agit sur le contexte du calque du widget à la place du contexte principal du widget. Cela signifie que resizeOverlayGL() est appelé à chaque fois que le widget est redimensionné. La nouvelle taille est passée dans les paramètres width et height pour la largeur et la hauteur respectivement. À réimplementer dans une sous-classe.

Il n'y a pas besoin d'appeler makeOverlayCurrent() car cela a déjà été effectué avant l'appel de cette fonction.

void QGLWidget::setAutoBufferSwap ( bool on ) [protected]

Si on est défini à true, l'échange automatique de buffers OpenGL est activé ; sinon il est désactivé.

Si on est défini à true et que le widget utilise un format à double buffers, le buffer de fond et le buffer de premier plan vont automatiquement être échangés après chaque appel de paintGL().

L'échange automatique de buffers est activé par défaut.

Voir aussi autoBufferSwap(), doubleBuffer() et swapBuffers().

void QGLWidget::setColormap ( const QGLColormap & cmap )

Définir la palette de couleurs pour ce widget à cmap. Normalement, seuls les widgets supérieurs peuvent avoir une palette de couleurs installée.

Voir aussi colormap().

void QGLWidget::setMouseTracking ( bool enable )

Si enable est défini à true alors le suivi de la souris est activé ; sinon il est désactivé.

void QGLWidget::swapBuffers ()

Échange le contenu de l'écran avec le buffer hors écran. Cela fonctionne seulement si le format du widget accepte le mode de double buffers.

Normalement, il n'y a pas besoin d'appeler cette fonction explicitement car cela est fait à chaque réaffichage du widget, c'est-à-dire après chaque appel de paintGL().

Voir aussi doubleBuffer(), setAutoBufferSwap() et QGLFormat::setDoubleBuffer().

void QGLWidget::updateGL () [virtual slot]

Met à jour le widget en appelant glDraw().

void QGLWidget::updateOverlayGL () [virtual slot]

Met à jour le calque du widget (si présent). Appelle la fonction virtuelle paintOverlayGL().

Le contexte de rendu du widget va devenir le contexte courant et la fonction initializeGL() va être appelée si elle n'a jamais été appelée.

Remerciements

Merci à Alexandre Laurent pour la traduction ainsi qu'à Lo?c Leguay, Jonathan Courtois et Claude Leloup pour leur relecture !