OpenGL ES2 avec Qt 5, Qt Designer en C++

Nous voulons que notreQOpenGLWidgetprenne toute la place possible en fonction que l’on agrandit ou rétrécit la fenêtre. Pour cela, on applique une disposition à notre « centralwidget » :

• clic droit sur MainWindow→ mettre en page→ mettre en page dans une grille ;
• clic gauche sur QLabel → sizePolicy → politique verticale → Fixed.

Nous voulons aussi supprimer les espaces vides en bordure :

• clic gauche sur centralwidget → Layout → mettre toutes les marges à 0.

Une fois les modifications faites, le widget OpenGL (en noir) prend toute la place possible.

La classeMainWidgetdoit être à la place de notreQOpenGLWidgetdont elle hérite. Pour cela, on l’indique à Qt Designer :

• clic droit sur QOpenGLWidget→promouvoir en → nom de la classe promue → MainWidget →ajouter → promouvoir.

Après avoir fait attention aux chemins des shaders et textures dans mainwidget.cpp :

"../qtgl2/vshader.glsl"

"../qtgl2/fshader.glsl"

"../qtgl2/cube.png"

Le programme fonctionne et le rendu OpenGL ES2 du dé est bien intégré.

Qt peut créer automatiquement une fonction qui s’effectuera seulement lorsque l’évènement se produit. Pour ce faire, dans Qt Designer :

• clic droit sur horizontalSlider →Aller au slot → valueChanged.

À ce moment, Qt creator crée une fonction dans la classe MainWindow avec un nom particulier. Ce nom particulier permet la connexion automatique de l’évènement avec cette fonction grâce à la fonctionQMetaObject::connectSlotsByName(MainWindow);qui est appelée dans le constructeur de la classeMainWindow.

Qt Creator nous envoie directement sur l’implémentation de la fonction afin que nous puissions la personnaliser. C’est une fonction membre deMainWindowque nous allons personnaliser. Il faut savoir que cette classe a automatiquement un membreuiqui possède des pointeurs vers tous les objets créés dans l’interface. Vous pouvez en savoir plus sur cet objetuien allant voir son implémentation dans le fichier « ui_mainwindow.h », généré automatiquement lors de la compilation.

Ici, nous allons utiliser la position du curseur pour gérer la profondeur de l’objet. Au passage, la fonction appelle update, car l’affichage du widget OpenGL aura changé. Nous allons donc remplir deux lignes de code dans cette fonction :

void MainWindow::on_horizontalSlider_valueChanged(int value)
{
    // passe le paramètre du slider au widget
    ui->openGLWidget->depth=value;
    // appelle l'affichage opengl
    ui->openGLWidget->update();
}

Il arrive que Qt Designer ne propose pas « d’aller au slot » ou que vous n’ayez pas utilisé Qt Designer pour créer vos interfaces. Dans ce cas, il suffit de définir vous-même une fonction avec le bon nom associé. Pour cela, il faut que la fonction soit de la forme :

void MainWindow::on_<object name>_<signal name>(<signal parameters>);

Nous allons en profiter pour créer la fonctionnalité de plein écran. Il suffit de définir la fonction :

void MainWindow::on_actionfullscreen_triggered()
{
    ui->label->setVisible(false);
    ui->statusbar->setVisible(false);
    ui->menubar->setVisible(false);
    ui->horizontalSlider->setVisible(false);
    showFullScreen();
}

Ici, on désactive tous les widgets différents du widget OpenGL et on passe en plein écran.

Une fois en plein écran, aucun bouton n’est accessible. On veut alors utiliser la touche échappe pour revenir à l’affichage en fenêtre.

Pour cela, on redéfinit la fonctionkeyPressEvent:

void MainWindow::keyPressEvent(QKeyEvent* event)
{
    if (event->type()==QEvent::KeyPress) {
        QKeyEvent* key = static_cast<QKeyEvent*>(event);
        if ( (key->key()==Qt::Key_Escape)  ) {
            ui->label->setVisible(true);
            ui->statusbar->setVisible(true);
            ui->menubar->setVisible(true);
            ui->horizontalSlider->setVisible(true);
            showNormal();
        }
    }
}

L’exemple cube OpenGL de Qt offre une architecture intéressante. C’est une bonne base pour aller plus loin. Le fait que la fonction d’affichage du modèle prenne en paramètre un shader permet de souligner l’importance d’une telle architecture. En pratique, pour des affichages OpenGL plus poussés, le programmeur devra avoir un affichage fortement dynamique et utiliser différents shaders pour un même modèle.

• Si le modèle est loin, un shader moins précis, mais plus léger sera utilisé.
• Si l’on souhaite réaliser des ombres, un shader spécial sera utilisé pour créer une texture de profondeur.
• On peut aussi vouloir d’autres passes de rendu pour l’anticrénelage ou simplement pour l’optimisation (deferred rendering).