Contenu

• Pas
• Partie 1 sur 3: Installation initiale
• Partie 2 sur 3: L'affichage () Fonction
• Partie 3 sur 3: Interactivité du programme

OpenGL est un outil de programmation 3D qui vous permet de créer des images 3D complexes à partir de formes simples. Dans cet article, vous apprendrez à dessiner avec son aide un cube simple qui peut être tourné en trois dimensions !

Pas

Partie 1 sur 3: Installation initiale

1. 1 Installez OpenGL. Commencez par un tutoriel sur la façon d'installer OpenGL sur votre ordinateur. Si vous avez déjà OpenGL et un compilateur C, vous pouvez ignorer cette étape et passer à la suivante.
2. 2 Créer un document. Créez un nouveau fichier dans votre éditeur de code préféré et enregistrez-le sous mycube.c
3. 3 Ajoutez #include. Voici les directives #include de base dont vous aurez besoin. Il est important de se rappeler que les directives des différents systèmes d'exploitation sont différentes et que vous devez donc tout choisir pour que le programme soit universel et puisse être exécuté sur n'importe quel système.

   // Comprend #include stdio.h> #include stdarg.h> #include math.h> #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include GLUT / glut.h> #else #include GL / glut.h> #endif

4. 4 Ajoutez des prototypes fonctionnels et des globals. L'étape suivante consiste à déclarer des prototypes fonctionnels.

   // Prototypes fonctionnels void display (); void specialKeys (); // Variables globales double rotate_y = 0; double rotation_x = 0 ;

5. 5 Définissez la fonction principale ().

   int main (int argc, char * argv []) // Initialise GLUT et traite les paramètres personnalisés glutInit (& argc, argv); // Demander une fenêtre avec prise en charge du double tampon, du tampon Z et des couleurs vraies glutInitDisplayMode (GLUT_DOUBLE

Partie 2 sur 3: L'affichage () Fonction

1. 1 Comprenez le but de la fonction display(). Tout le travail de rendu du cube retombera sur les lignes fragiles de cette fonction. L'idée générale est la suivante : vous allez dessiner six faces distinctes du cube et les placer dans leurs positions respectives.
   • Pour chaque face, vous définirez quatre coins, et OpenGL les connectera avec des lignes et les remplira avec la couleur de votre choix. Comment faire cela sera expliqué ci-dessous.
2. 2 Ajoutez la fonction glClear(). Tout d'abord, lorsque vous travaillez avec cette fonction, nous avons besoin couleur claire et z-buffer... Sans cela, l'ancienne sera visible sous la nouvelle image, et les objets dessinés par le programme seront mal positionnés.

   void display () // Efface l'écran et le tampon Z glClear (GL_COLOR_BUFFER_BIT

   • Faites attention aux deux dernières lignes. Ce sont les fonctions glRincer (); et glutSwapBuffers ();, donnant l'effet de double tampon, qui a été décrit ci-dessus.

Partie 3 sur 3: Interactivité du programme

1. 1 Ajoutez la fonction SpecialKeys(). En principe, tout est presque prêt, mais le cube n'est que dessiné et non tourné. Pour ce faire, vous devez créer la fonction SpecialKeys(), qui vous permettra de faire pivoter le cube en appuyant sur les touches fléchées !
   • C'est pour cette fonction que les variables globales rotate_x et rotate_y ont été déclarées. Lorsque vous appuyez sur les touches fléchées gauche et droite, la valeur rotate_y augmente ou diminue de cinq degrés. La valeur de rotate_x changera de la même manière, mais cette fois en appuyant sur les touches fléchées haut et bas.

   void specialKeys (touche int, int x, int y) {// Flèche droite - augmente la rotation de 5 degrés si (touche == GLUT_KEY_RIGHT) rotate_y + = 5; // Flèche gauche - Diminuer la rotation de 5 degrés else if (key == GLUT_KEY_LEFT) rotate_y - = 5; sinon si (clé == GLUT_KEY_UP) rotate_x + = 5; sinon si (clé == GLUT_KEY_DOWN) rotate_x - = 5; // Demande d'actualisation de l'écran glutPostRedisplay (); }

2. 2 Ajoutez glRotation (). La dernière chose que nous ferons est d'ajouter une ligne qui nous permettra de faire pivoter l'objet. Retour à la fonction affichage () et avant la description de la face AVANT ajouter :

   // Réinitialiser les transformations glLoadIdentity (); // Rotation lorsque l'utilisateur change Les valeurs rotate_x et rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (rotate_y, 0.0, 1.0, 0.0); // Face multicolore - FRONT ....

   • Veuillez noter que la syntaxe glRotatef ()qui est similaire à la syntaxe de glColor3f () et glVertex3f (), mais nécessite toujours quatre paramètres. Le premier est l'angle de rotation en degrés. Les trois suivants sont les axes le long desquels la rotation a lieu, dans l'ordre x, y, z. Pour l'instant, nous devons faire pivoter le cube le long de deux axes, x et y.
   • Toutes les transformations que nous définissons dans le programme nécessitent des lignes similaires. Fondamentalement, nous représentons la rotation d'un objet le long de l'axe des x comme un changement de la valeur de rotate_x, et la rotation le long de l'axe des y comme un changement de la valeur de rotate_y. Cependant, OpenGL regroupera tout dans une seule matrice de transformation. Chaque fois que vous appelez display, vous créerez une matrice de transformation, et glLoadIdentity () vous permettra de commencer avec une nouvelle matrice à chaque fois.
   • Les autres fonctions de transformation que vous avez peut-être utilisées sont glTranslatef () et glScalef (). Ils sont similaires à glRotatef(), sauf qu'ils ne nécessitent que trois paramètres : les valeurs x, y et z pour redimensionner et mettre à l'échelle l'objet.
   • Pour que tout s'affiche correctement lorsque les trois transformations sont appliquées à un seul objet, vous devez définir les transformations dans l'ordre approprié, à savoir glTranslate, glRotation, glScale - et jamais autrement. OpenGL transforme l'objet en lisant le programme de bas en haut. Pour mieux comprendre cela, imaginez à quoi ressemblerait le cube 1x1x1 après toutes les transformations si OpenGL les appliquait dans l'ordre indiqué (de haut en bas), puis réfléchissez à la façon dont OpenGL traiterait le cube en lisant les instructions de bas en haut.
3. 3 Ajoutez les commandes suivantes pour mettre le cube à l'échelle deux fois dans les directions x et y, pour faire pivoter le cube de 180 degrés sur l'axe y et pour déplacer le cube de 0,1 sur l'axe x. Assurez-vous que toutes les commandes pertinentes, y compris les commandes glRotate() précédemment données, sont dans le bon ordre. Si vous avez peur de vous tromper, consultez la version finale du programme à la fin de l'article.

   // Plus de transformations glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0,0, 1,0, 0,0); glScalef (2,0, 2,0, 0,0);

4. 4 Compilez et exécutez le code. Disons que vous utilisez gcc comme compilateur, alors entrez les commandes suivantes dans votre terminal :

   Sous Linux : gcc cube.c -o cube -lglut -lGL ./ mycube Sur Mac : gcc -o foo foo.c -framework GLUT -framework OpenGL ./ mycube Sous Windows : gcc -Wall -ofoo foo.c -lglut32cu - lglu32 -lopengl32 ./ mycube

5. 5 Vérifiez le code final. Voici le code final créé par l'auteur de l'article, qui ne traduit pas les commentaires.

   // // Fichier : mycube.c // Auteur : Matt Daisley // Création : 25/04/2012 // Projet : Code source pour Make a Cube en OpenGL // Description : Crée une fenêtre OpenGL et dessine un cube 3D / / Que l'utilisateur peut faire pivoter à l'aide des touches fléchées // // Contrôles : Flèche gauche - Faire pivoter à gauche // Flèche droite - Faire pivoter à droite // Flèche haut - Faire pivoter vers le haut // Flèche bas - Faire pivoter vers le bas // ------ -------------------------------------------------- - // Comprend // -------------------------------- - -------------- #include stdio.h> #include stdarg.h> #include math.h> #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include GLUT / glut.h> #else # include GL / glut.h> #endif // ---------------------------------------- - ------------------ // Prototypes de fonctions // ------------------------- - -------------------------------- affichage vide (); void specialKeys (); // ------------------------------------------------ ---------- // Variables globales // ---------------------------------- ------------------------ double rotation_y = 0; double rotation_x = 0 ; // ------------------------------------------------ ---------- // afficher () Fonction de rappel // ------------------------------- --------------------------- void display () // Clear screen et Z-buffer glClear (GL_COLOR_BUFFER_BIT // ------ -------------------------------------------------- - // SpecialKeys () Fonction de rappel // ---------------------------------------- - ------------------ void specialKeys (touche int, int x, int y) {// Flèche droite - augmente la rotation de 5 degrés si (touche == GLUT_KEY_RIGHT) rotate_y + = 5; // Flèche gauche - diminue la rotation de 5 degrés else if (key == GLUT_KEY_LEFT) rotate_y - = 5; else if (key == GLUT_KEY_UP) rotate_x + = 5; else if (key == GLUT_KEY_DOWN) rotate_x - = 5; // Demande de mise à jour de l'affichage glutPostRedisplay ();} // ----------------------------------- - ---------------------- // fonction principale () // ------------------- - -------------------------------------- int main (int argc, char * argv [ ] ) GLUT_RGB