OpenGL

Création du contexte

Les deux auteur et traducteur

Site personnel

Traducteur : Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

Navigation

Tutoriel précédent : introduction

 

Sommaire

 

Tutoriel suivant : dessiner des polygones

I. Fenêtre et contexte OpenGL

Avant de dessiner quoi que ce soit à l'écran, vous devez initialiser OpenGL. Cela se fait à travers la création d'un contexte OpenGL : une machine à états qui stocke toutes les données relatives au rendu de votre application. Lorsque l'application est fermée, le contexte OpenGL est détruit et tout est nettoyé.

Le problème est que la création de la fenêtre et d'un contexte OpenGL ne fait pas partie de la spécification OpenGL. Cela signifie que cela est différent pour chaque plateforme disponible ! Le développement d'applications utilisant OpenGL a pour principal objectif d'être portable, donc c'est la dernière chose dont nous avons besoin. Heureusement, il y a des bibliothèques faisant abstraction de ce processus, ainsi nous pouvons garder le même code pour toutes les plateformes.

Bien que les bibliothèques disponibles ont toutes des avantages et désavantages, elles ont toutes en commun une même façon de procéder. Vous commencez en spécifiant les propriétés de la fenêtre de jeu telles que le titre ou la taille et les propriétés du contexte OpenGL, comme le niveau d'anticrénelage. Votre application débutera ensuite la boucle événementielle, qui contient un ensemble de tâches importantes devant être effectuées encore et encore jusqu'à la fermeture de la fenêtre. Ces tâches prennent généralement en charge les événements de la fenêtre tels que les clics de souris, mettent à jour l'état du rendu et effectuent le rendu.

La façon de faire ressemblera à quelque chose comme ce pseudo-code :

 
Sélectionnez
#include <entetes_bibliothèque>

int main()
{
    creerFenetre(titre, largeur, hauteur);
    creerContextOpenGL(parametres);

    while (fenetreOuverte)
    {
        while (evenement = nouvelEvenement())
            gererEvenement(evenement);

        misAJourScene();

        dessineGraphismes();
        afficheGraphismes();
    }

    return 0;
}

Lors du rendu d'une image, le résultat sera stocké dans un tampon hors écran connu sous le nom de « back buffer » (ou tampon arrière) pour être certain que l'utilisateur ne verra que le résultat final. La fonction afficheGraphismes() copiera le résultat du tampon arrière sur le tampon visible de la fenêtre, le « front buffer » (ou tampon avant). Toute application produisant des graphismes temps réel possède une façon de faire similaire à celle-ci et cela, peu importe la bibliothèque ou le code natif.

Par défaut, les bibliothèques créeront un contexte OpenGL supportant les fonctions antérieures à OpenGL 3. C'est malheureux, car nous ne sommes pas intéressés par celles-ci et elles pourraient devenir inaccessibles dans le futur. La bonne nouvelle est qu'il est possible d'indiquer au pilote que notre application est prête pour le futur et ne dépend pas de ces vieilles fonctions. La mauvaise nouvelle est que pour le moment seul la bibliothèque GLFW nous permet de le spécifier. Ce petit défaut n'a aucune conséquence négative pour le moment, donc cela ne doit pas influencer votre choix sur la bibliothèque, mais l'avantage d'un tel « core-profile » est que l'appel accidentel à l'une de ces vieilles fonctions provoque une erreur d'opération invalide pour vous avertir immédiatement.

Le support des fenêtres redimensionnables avec OpenGL apporte des complexités, car les ressources doivent être rechargées et les tampons doivent être recréés pour correspondre à la taille de la nouvelle fenêtre. Il est plus facile de ne pas se préoccuper avec de tels détails pour le moment, donc nous allons seulement gérer une taille fixe (plein écran) de fenêtre.

II. Configuration

Au lieu de lire ce chapitre, vous pouvez utiliser ce code standard OpenGL, qui rend très facile la configuration d'un projet OpenGL avec toutes les bibliothèques nécessaires. Vous devez juste installer SOIL séparément.

La première chose à faire lorsque vous commencez un nouveau projet OpenGL est de lier dynamiquement OpenGL.

  • Windows : ajoutez opengl32.lib à votre éditeur de liens.
  • Linux : incluez -lGL dans les options de votre compilateur.
  • OS X : ajoutez -framework OpenGL aux options de votre compilateur.

Assurez-vous de ne pas inclure opengl32.dll avec votre application. Ce fichier est déjà inclus dans Windows et peut être différent entre chaque version, causant donc des problèmes avec les autres ordinateurs.

Le reste des étapes dépend de la bibliothèque que vous avez choisie pour créer la fenêtre et le contexte.

III. Bibliothèques

Il y a plusieurs bibliothèques qui peuvent créer une fenêtre et son contexte OpenGL. Il n'y a pas de meilleure bibliothèque, car chacune possède ses propres besoins et idéaux. J'ai décidé de décrire le processus pour trois des plus populaires bibliothèques, mais vous pouvez trouver des guides plus détaillés sur leur site officiel. Tout code après ce chapitre sera indépendant de la bibliothèque que vous avez choisie.

III-A. SFML

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.

III-B. SDL

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.

III-C. GLFW

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.

III-D. Autres

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.

IV. SFML

Le contexte OpenGL est créé implicitement lors de l'ouverture d'une nouvelle fenêtre SFML, donc c'est tout ce que vous avez à faire. SFML apporte aussi des outils graphiques, mais comme nous allons utiliser OpenGL directement, nous n'en avons pas besoin.

IV-A. Compilation

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.

Les fichiers de la bibliothèque SFML possèdent une convention de nommage simple pour les différentes configurations. Si vous souhaitez faire une liaison dynamique, retirez le -s de la fin du nom, définissez SFML_DYNAMIC et copiez les bibliothèques partagées. Si vous souhaitez utiliser les binaires avec les symboles de débogage, ajoutez à la fin -d au nom des fichiers.

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

 
Sélectionnez
#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.

IV-B. Code

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

 
Sélectionnez
#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.

 
Sélectionnez
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.

 
Sélectionnez
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.

 
Sélectionnez
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 :

 
Sélectionnez
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 :

Image non disponible

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.

V. SDL

La SDL apporte plusieurs modules, mais pour la création d'une fenêtre et son contexte OpenGL, nous nous intéressons qu'au module vidéo. Il se charge de tout ce dont nous avons besoin, donc voyons comment l'utiliser.

V-A. Compilation

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 :

 
Sélectionnez
#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.

V-B. Code

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

 
Sélectionnez
#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 :

 
Sélectionnez
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 :

 
Sélectionnez
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().

 
Sélectionnez
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 :

 
Sélectionnez
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 :

 
Sélectionnez
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.

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

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

Image non disponible

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

VI. GLFW

GLFW est conçu pour utiliser OpenGL. C'est donc la plus simple à utiliser pour nos projets.

VI-A. Compilation

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.

Vous pouvez aussi lier dynamiquement GLFW si vous le souhaitez. Simplement, liez GLFWDLL et copiez la bibliothèque partagée avec votre exécutable.

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

 
Sélectionnez
#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.

VI-B. Code

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

 
Sélectionnez
#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.

 
Sélectionnez
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.

 
Sélectionnez
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 :

 
Sélectionnez
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 :

 
Sélectionnez
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.

 
Sélectionnez
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.

Image non disponible

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.

VII. Une dernière chose

Malheureusement, nous ne pouvons pas encore appeler les fonctions dont nous avons besoin. Cela est ainsi, car c'est de la responsabilité du constructeur de la carte graphique d'implémenter les fonctionnalités d'OpenGL dans leur pilote suivant ce que la carte supporte. Vous ne souhaiteriez pas que votre programme ne soit compatible qu'avec une simple version du pilote et de la carte graphique, donc nous devons user d'astuces.

Votre programme doit vérifier quelles sont les fonctions disponibles au cours de son exécution et les lier dynamiquement. Il faut trouver les adresses des fonctions, les assigner à des pointeurs de fonctions et les appeler. Cela ressemble au code suivant :

N'essayez pas ce code, ce n'est qu'une démonstration.

 
Sélectionnez
// Spécifier le prototype de fonction
typedef void (*GENBUFFERS) (GLsizei, GLuint*);

// Charger l'adresse de la fonction et l'assigner à un pointeur de fonction
GENBUFFERS glGenBuffers = (GENBUFFERS)wglGetProcAddress("glGenBuffers");
// ou Linux:
GENBUFFERS glGenBuffers = (GENBUFFERS)glXGetProcAddress((const GLubyte *) "glGenBuffers");
// ou OSX:
GENBUFFERS glGenBuffers = (GENBUFFERS)NSGLGetProcAddress("glGenBuffers");

// Appeler la fonction comme d'habitude
GLuint buffer;
glGenBuffers(1, &buffer);

Laissez-moi vous affirmer qu'il est totalement normal d'être effrayé par ce code. Vous pouvez ne pas être habitué avec le concept de pointeur de fonction, mais au moins, essayez de comprendre à peu près ce qui se passe. Vous pouvez imaginer qu'effectuer les étapes de définitions de prototypes et de recherche d'adresses de fonctions est très ennuyant et qu'à la fin, ce n'est rien de plus qu'une totale perte de temps.

La bonne nouvelle est qu'il y a des bibliothèques pour résoudre cette difficulté pour nous. La plus populaire et, actuellement, la plus maintenue est GLEW et il n'y a aucune raison que cela ne change. Toutefois, la bibliothèque alternative GLEE fonctionne pratiquement de la même façon sauf pour l'initialisation et le code de libération de ressource.

Si vous n'avez pas encore compilé GLEW, faites-le. Nous allons maintenant ajouter GLEW dans notre projet.

  • Commencez par lier votre projet avec la bibliothèque statique du dossier lib. C'est soit le fichier glew32s.lib ou GLEW suivant votre plateforme.
  • Ajoutez le dossier include dans vos chemins d'entêtes.

Maintenant, ajoutez l'entête dans votre programme, mais assurez-vous qu'il est inclus avant les entêtes d'OpenGL ou de la bibliothèque que vous utilisez pour créer votre fenêtre.

 
Sélectionnez
#define GLEW_STATIC
#include <GL/glew.h>

N'oubliez pas le GLEW_STATIC que ce soit en utilisant la directive du préprocesseur ou en ajoutant -DGLEW_STATIC aux paramètres de votre compilateur ou de votre projet.

Si vous préférez lier dynamiquement GLEW, oubliez la définition et liez avec le fichier glew32.lib au lieu du fichier glew32s.lib sous Windows. N'oubliez pas d'inclure le fichier glew32.dll ou libGLEW.so avec votre exécutable.

Maintenant, il ne reste plus qu'à appeler la fonction glewInit() après la création de votre fenêtre et de votre contexte OpenGL. La ligne glewExperimental est nécessaire afin de forcer GLEW à utiliser une méthode OpenGL moderne pour vérifier la présence des fonctions.

 
Sélectionnez
glewExperimental = GL_TRUE;
glewInit();

Assurez-vous que vous avez défini correctement votre projet en appelant la fonction glGenBuffers, qui a été chargée par GLEW pour vous !

 
Sélectionnez
GLuint vertexBuffer;
glGenBuffers(1, &vertexBuffer);

printf("%u\n", vertexBuffer);

Votre programme devrait compiler et s'exécuter sans problèmes et afficher le nombre 1 dans votre console. Si vous avez besoin d'aide avec GLEW, vous pouvez consulter le site officiel ou demander dans le forum.

Maintenant que nous avons fini le travail de configuration et d'initialisation, je vous conseille de faire une copie de votre projet actuel afin que vous n'ayez pas à réécrire ce code de base à chaque fois que vous démarrez un nouveau projet.

Maintenant, allons afficher des choses !

VIII. Remerciements

Cet article est une traduction autorisée dont le texte original peut être trouvé sur open.gl.

Navigation

Tutoriel précédent : introduction

 

Sommaire

 

Tutoriel suivant : dessiner des polygones

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Licence Creative Commons
Le contenu de cet article est rédigé par Alexander Overvoorde et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 3.0 non transposé.
Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright © 2013 Developpez.com.