OpenGL

SFML est une bibliothèque C++ multimédia et multiplateforme qui permet d'accéder aux graphiques, entrées utilisateur, audio, réseau et au système. La contrepartie à utiliser cette bibliothèque est qu'elle essaie d'être une solution tout-en-un. Vous n'avez peu voire aucun contrôle sur la création du contexte OpenGL, car elle a été conçue pour être utilisée avec son propre ensemble de fonctions de dessin.

SDL est aussi une bibliothèque multimédia multiplateforme, mais en C. Cela la rend un peu plus âpre à utiliser pour les programmeurs C++, mais c'est une excellente alternative à SFML. Elle supporte plus de plateformes exotiques et le plus important, elle offre plus de contrôle sur la création d'un contexte OpenGL que la SFML.

GLFW, comme son nom l'indique, est une bibliothèque C spécifiquement conçue pour être utilisée avec OpenGL. Contrairement à la SDL et la SFML, elle ne fournit que le nécessaire : la création de la fenêtre, du contexte et la gestion des entrées utilisateur. Parmi les trois bibliothèques, c'est celle qui offre le plus de contrôle sur la création du contexte OpenGL.

Il y a quelques autres options, comme freeglut et OpenGLUT, mais je pense personnellement que les bibliothèques susmentionnées sont largement supérieures en contrôle, facilité d'utilisation et surtout qu'elles sont les plus à jour.

Après avoir téléchargé les binaires de la SFML ou de l'avoir compilée vous-même, vous allez trouver les fichiers nécessaires dans les dossiers lib et include.

• Ajoutez le dossier lib dans les chemins de vos bibliothèques et effectuez l'édition de liens avec sfml-system et sfml-window. Avec Visual Studio sur Windows, liez les fichiers sfml-system-s et sfml-window-s du dossier lib/vc2008.
• Ajoutez le dossier include dans les chemins de vos entêtes.

Pour vérifier que vous avez fait cela correctement, essayez de compiler et exécuter le code suivant :

#include <SFML/System.hpp>

int main()
{
    sf::sleep(sf::seconds(1.f));
    return 0;
}

Cela devrait afficher une application console et la quitter après une seconde. Si vous rencontrez un quelconque souci, vous pouvez trouver des informations détaillées pour Visual Studio, Code::Blocks et gcc dans les tutoriels sur le site de la SFML.

Commencez par inclure le module de fenêtre et définissez le point d'entrée de votre application.

#include <SFML/Window.hpp>

int main()
{
    return 0;
}

Une fenêtre peut être ouverte en créant une nouvelle instance de sf::Window. Le constructeur de base prend en argument une structure sf::VideoMode, un titre pour la fenêtre et un style de fenêtre. La structure sf::VideoMode indique la largeur, la hauteur et optionnellement la profondeur des pixels de la fenêtre. Finalement, le besoin de créer une fenêtre à taille fixe est spécifié en surchargeant le style par défaut Style::Resize|Style::Close. Il est aussi possible de créer une fenêtre plein écran en passant Style::Fullscreen comme style de fenêtre.

sf::ContextSettings settings;
settings.depthBits = 24;
settings.stencilBits = 8;
settings.antialiasingLevel = 2; // Optional

sf::Window window(sf::VideoMode(800, 600), "OpenGL", sf::Style::Close, settings);

Le constructeur peut aussi prendre une structure sf::ContextSettings qui vous permet d'indiquer le niveau d'anticrénelage et la précision des tampons de profondeur (« depth buffer ») et de pochoir (« stencil buffer »). Ces deux tampons seront détaillés par la suite, donc vous ne devez pas vous en inquiéter pour le moment. Dans la dernière version de SFML, vous devez les indiquer manuellement avec le code ci-dessus.

Lorsque vous exécutez ceci, vous allez voir que l'application se ferme immédiatement après la création de la fenêtre. Ajoutons la boucle événementielle pour corriger cela.

bool running = true;
while (running)
{
    sf::Event windowEvent;
    while (window.pollEvent(windowEvent))
    {

    }
}

Lorsque quelque chose se produit dans votre fenêtre, un événement est posté dans la queue événementielle. Il y a une grande variété d'événements, dont les changements de la taille de la fenêtre, les déplacements de la souris et les appuis sur les touches du clavier. C'est à vous de décider quels événements déclenchent des actions additionnelles, mais il y a au moins un événement que vous devez gérer pour que votre application s'exécute correctement.

switch (windowEvent.type)
{
case sf::Event::Closed:
    running = false;
    break;
}

Lorsque l'utilisateur essaie de fermer la fenêtre, l'événement Closed est envoyé et nous y réagissons en fermant l'application. Essayez de retirer cette ligne et vous allez voir qu'il est impossible de fermer la fenêtre avec des méthodes classiques. Si vous souhaitez une fenêtre plein écran, vous devez ajouter la touche « Échap » comme méthode pour fermer la fenêtre :

case sf::Event::KeyPressed:
    if (windowEvent.key.code == sf::Keyboard::Escape)
        running = false;
    break;

Vous avez votre fenêtre et les actions pour les événements les plus importants, donc vous êtes maintenant prêt à mettre quelque chose sur l'écran. Après avoir dessiné quelque chose, vous pouvez échanger le tampon arrière et le tampon avant avec window.display().

Lorsque vous exécutez votre application, vous devriez voir quelque chose comme ceci :

Sachez que la SFML vous permet d'avoir plusieurs fenêtres. Si vous souhaitez utiliser cette fonctionnalité, assurez-vous d'appeler window.setActive() pour activer une fenêtre afin de dessiner dessus.

Maintenant que vous avez une fenêtre et un contexte, il reste une dernière chose à faireUne dernière chose.

Après avoir téléchargé les binaires de la SDL, ou de les avoir compilés vous-même, vous allez trouver les fichiers nécessaires dans les dossiers lib et include.

• Ajoutez le dossier lib aux chemins de vos bibliothèques et rajoutez SDL2 et SDL2main à l'éditeur de liens.
• SDL utilise la liaison dynamique, assurez-vous donc que les bibliothèques partagées (SDL2.dll, SDL2.so) accompagnent votre exécutable.
• Ajoutez le dossier include aux chemins de vos entêtes.

Pour vérifier que vous êtes prêt, essayez de compiler et d'exécuter le morceau de code qui suit :

#include <SDL.h>

int main(int argc, char *argv[])
{
    SDL_Init(SDL_INIT_EVERYTHING);

    SDL_Delay(1000);

    SDL_Quit();
    return 0;
}

Il devrait afficher une application console et la quitter après une seconde. Si vous rencontrez un quelconque problème, vous pouvez trouver des informations détaillées pour toutes les plateformes et compilateurs dans les tutoriels sur Internet.

Commencez par définir le point d'entrée de votre application et incluez les entêtes de la SDL.

#include <SDL.h>
#include <SDL_opengl.h>

int main(int argc, char *argv[])
{
    return 0;
}

Pour utiliser la SDL dans une application, vous devez dire à la SDL quels sont les modules dont vous avez besoin et à quel moment elle doit les décharger. Vous pouvez faire ceci avec les deux lignes suivantes :

SDL_Init(SDL_INIT_VIDEO);
...
SDL_Quit();
return 0;

La fonction SDL_Init() prend une combinaison de bits pour déterminer les modules à charger. Le module vidéo inclut tout ce dont vous avez besoin pour créer une fenêtre et un contexte OpenGL.

Avant de faire quoi que ce soit d'autre, nous devons d'abord indiquer à la SDL que nous souhaitons un contexte OpenGL 3.2 compatible avec les versions supérieures :

SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);

Vous avez aussi besoin de dire à la SDL de créer un tampon de pochoir, qui sera utile pour la suite des chapitres. Après cela, nous créons une fenêtre avec la fonction SDL_CreateWindow().

SDL_Window* window = SDL_CreateWindow("OpenGL", 100, 100, 800, 600, SDL_WINDOW_OPENGL);

Le premier argument indique le titre de la fenêtre, les deux suivants la position X et Y de celle-ci et les deux prochains, la largeur et la hauteur. Si la position n'importe pas, vous pouvez utiliser SDL_WINDOWPOS_UNDEFINED ou SDL_WINDOWPOS_CENTERED pour le deuxième et troisième argument. Le dernier paramètre indique les propriétés de la fenêtre, telles que :

• SDL_WINDOW_OPENGL - créer une fenêtre préparée pour OpenGL.
• SDL_WINDOW_RESIZABLE - créer une fenêtre redimensionnable.
• Optionnel SDL_WINDOW_FULLSCREEN - créer une fenêtre plein écran.

Après avoir créé la fenêtre, vous devez créer le contexte OpenGL :

SDL_GLContext context = SDL_GL_CreateContext(window);
...
SDL_GL_DeleteContext(context);

Le contexte doit être détruit juste avant l'appel à la fonction SDL_Quit() pour libérer les ressources.

Ensuite arrive la partie la plus importante du programme, la boucle événementielle :

SDL_Event windowEvent;
while (true)
{
    if (SDL_PollEvent(&windowEvent))
    {
        if (windowEvent.type == SDL_QUIT) break;
    }

    SDL_GL_SwapWindow(window);
}

La fonction SDL_PollEvent() vérifiera s'il y a un quelconque nouvel événement à gérer. Un événement peut être n'importe quelle action telle qu'un clic de souris ou le déplacement de la fenêtre par l'utilisateur. Pour le moment, le seul événement que vous devez gérer est le clic de l'utilisateur sur la croix dans le coin de la fenêtre. En sortant de la boucle principale, SDL_Quit() est appelé provoquant la destruction de la fenêtre et de la surface graphique. La fonction SDL_GL_SwapWindow() permet de gérer l'échange des tampons avant et du tampon arrière après que de nouvelles choses ont été dessinées par votre application.

Si vous avez une fenêtre plein écran, il serait préférable d'utiliser la touche « Échap » comme méthode pour fermer la fenêtre.

if (windowEvent.type == SDL_KEYUP &&
    windowEvent.key.keysym.sym == SDLK_ESCAPE) break;

Maintenant, si vous lancez votre application, vous devriez voir quelque chose comme :

Maintenant que vous avez une fenêtre et un contexte, il reste une dernière chose à faireUne dernière chose.

Après avoir téléchargé les binaires GLFW à partir du site officiel ou après avoir compilé les binaires vous-même, vous allez trouver les fichiers d'entêtes dans le dossier include et les bibliothèques pour votre compilateur dans l'un des dossiers lib.

• Ajoutez le dossier lib correspondant à votre configuration dans le chemin de vos bibliothèques et liez votre projet à GLFW.
• Ajoutez le dossier include dans les chemins de vos entêtes.

Voici un simple morceau de code pour vérifier votre configuration :

#include <GLFW/glfw3.h>
#include <thread>

int main()
{
    glfwInit();
    std::this_thread::sleep_for(std::chrono::seconds(1));
    glfwTerminate();
}

Cela devrait afficher une application console et la quitter après une seconde. Si vous rencontrez un quelconque souci, demandez sur le forum pour recevoir de l'aide.

Démarrez en incluant l'entête de la GLFW et définissez le point d'entrée de votre application.

#include <GLFW/glfw3.h>

int main()
{
    return 0;
}

Pour utiliser GLFW, vous devez l'initialiser au démarrage du programme et vous devez lui donner une chance de libérer les ressources à la fermeture. Les fonctions glfwInit() et glfwTerminate() sont prévues à cet effet.

glfwInit();
...
glfwTerminate();

La prochaine chose à faire est de créer et configurer la fenêtre. Avant d'appeler la fonction glfwCreateWindow(), nous définissons d'abord quelques options.

glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL", nullptr, nullptr); // Windowed
GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL", glfwGetPrimaryMonitor(), nullptr); // Fullscreen

Vous allez immédiatement remarquer que les trois premières lignes de code ne sont pertinentes que pour cette bibliothèque. Elles indiquent que nous avons besoin d'un contexte OpenGL ayant une version minimum 3.2. L'option GLFW_OPENGL_PROFILE indique que nous souhaitons un contexte qui ne supporte que les fonctionnalités du profil principal.

Les deux premiers paramètres de la fonction glfwCreateWindow() indiquent la largeur et la hauteur de la surface de dessin et le troisième paramètre indique le titre de la fenêtre. Le quatrième paramètre doit être NULL pour avoir le mode fenêtre et glfwGetPrimaryMonitor() pour avoir le mode plein écran. Le dernier paramètre permet de spécifier un contexte OpenGL déjà existant afin de partager les ressources comme les textures. La fonction glfwWindowHint() est utilisée pour spécifier des besoins supplémentaires concernant la fenêtre.

Après avoir créé la fenêtre, le contexte OpenGL doit être rendu actif :

glfwMakeContextCurrent(window);

Ensuite arrive la boucle événementielle, qui, dans le cas de GLFW, fonctionne un peu différemment des autres bibliothèques. GLFW utilise une boucle événementielle appelée « fermée ». Cela signifie que vous n'avez qu'à gérer les événements que lorsque vous en avez besoin. En clair, votre boucle événementielle semblera très simple :

while(!glfwWindowShouldClose(window))
{
    glfwSwapBuffers(window);
    glfwPollEvents();
}

Les seules fonctions nécessaires dans la boucle sont glfwSwapBuffers() pour échanger le tampon arrière avec le tampon avant après avoir fini le rendu et la fonction glfwPollEvents() pour mettre à jour les événements. Si vous avez une application plein écran, vous devez gérer la touche « Échap » pour facilement revenir au bureau.

if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
    glfwSetWindowShouldClose(window, GL_TRUE);

Si vous souhaitez en apprendre plus sur la gestion des entrées, consultez la documentation.

Vous devez maintenant avoir une fenêtre ou une surface plein écran avec un contexte OpenGL. Avant de pouvoir afficher quoi que ce soit, il reste une dernière chose à faireUne dernière chose.