Compiler un projet 3D OpenGL en C sous Mac OS X ou Linux

« Hello Word » de programmation OpenGL en C sous Linux (Debian).
Pour cela ont peut utiliser la librairie GLUT pour réaliser un cube manipulable.

Sous Linux :

#include 

Compiler :

1
gcc -o nom_executable  source.c -L/usr/X11R6/lib -lglut

Sur Mac OS X : avec Xcode, X11 et les Developper Tools :

1
2
3
#include <openGL/gl.h>	   // Fichier Header pour OpenGL32 Library
#include <openGL/glu.h>    // Fichier Header pour GLu32 Library
#include <glut/glut.h>	  // Fichier Header pour GLut Library

Et utiliser la commande suivante pour la compilation :

1
gcc -framework GLUT -framework OpenGL -framework Cocoa source.c -o nom_executable
Cube en 3D - OpenGL - Mac OS X

Cube en 3D - OpenGL - Mac OS X

Voici un petit exemple de programme OpenGL : un cube en 3D :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
//----------------------------------------------------------------------
// Cube en 3D avec OpenGL
//----------------------------------------------------------------------
 
//----------------------------------------------------------------------
// LIBRAIRIES
//----------------------------------------------------------------------
// LIBRAIRIES et COMMANDE Linux :
// #include <gl/glut.h>
// #include <stdlib.h>
// gcc -o prog.exe  main.c -L/usr/X11R6/lib -lglut
 
#include <openGL/gl.h>		// Header File For The OpenGL32 Library
#include <openGL/glu.h>		// Header File For The GLu32 Library
#include <glut/glut.h>		// Header File For The GLut Library
 
//----------------------------------------------------------------------
// DECLARATION DES FONCTIONS
//----------------------------------------------------------------------
void keyboard(unsigned char key, int x, int y);
void display();
void mouse(int button, int state, int x, int y);
void mousemotion(int x, int y);
void reshape(int x, int y);
 
// STRUCTURE
typedef struct {
  float x, y, z, r, g, b;
} point;
 
//----------------------------------------------------------------------
// VARIABLES GLOBALES
//----------------------------------------------------------------------
float xold, yold, anglex = 0, angley = 0, presse = 0;
 
// Notre cube :
// Tout les points
point p[8] = {
{-0.5, -0.5, 0.5, 1.0, 0.0, 0.0},
{-0.5, 0.5, 0.5, 0.0, 1.0, 0.0},
{0.5, 0.5, 0.5, 0.0, 0.0, 1.0},
{0.5, -0.5, 0.5, 1.0, 1.0, 1.0},
{-0.5, -0.5, -0.5, 1.0, 0.0, 0.0},
{-0.5, 0.5, -0.5, 0.0, 1.0, 0.0},
{0.5, 0.5, -0.5, 0.0, 0.0, 1.0},
{0.5, -0.5, -0.5, 1.0, 1.0, 1.0}};
 
// Toutes les faces
int f[6][4] = {
{0, 1, 2, 3},
{3, 2, 6, 7},
{4, 5, 6, 7},
{0, 1, 5, 4},
{1, 5, 6, 2},
{0, 4, 7, 3}};
 
//----------------------------------------------------------------------
// MAIN
//----------------------------------------------------------------------
int main(int argc, char* argv[]){
  glutInit(&argc, argv);             // Initialise la b. glut
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); // param d'affichage
  glutInitWindowPosition(200, 200);  // Fenetre : position
  glutInitWindowSize(250, 250);      // Fenetre : taille
  glutCreateWindow("OpenGL - Cube 3D - Nicotouch.com");          // Fenetre : Nom
 
  glClearColor(0, 0, 0, 0);          // Défaut : Couleur de fond
  glPointSize(2.0);                  // Taille d'un point
  glEnable(GL_DEPTH_TEST);           // Utilisation du Tampon de Profondeur
 
  // Gestion des évènement :
  glutDisplayFunc(affichage);        // Fonction qui gère l'affichage
  glutKeyboardFunc(clavier);         // Fonction qui gère les commandes clavier
 
  glutMouseFunc(mouse);              // Prendre en compte les fonctions
  glutMotionFunc(mousemotion);       // Fonction de gestion du clic de la Souris
  glutReshapeFunc(reshape);          // Fonction de gestion du redimentionnement de la fenêtre
  glutMainLoop();                    // Boucle d'attente des évènements
 
}
 
//----------------------------------------------------------------------
// CLAVIER : gère l'activation de différent mode d'affichage
//----------------------------------------------------------------------
void keyboard(unsigned char key, int x, int y){
  switch(key){ // en fonction des touches, on affiche :
    case 'p':
      glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // Texture
      glutPostRedisplay(); // Raffraichissement
      break;
    case 'f':
      glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // Arrête
      glutPostRedisplay();
      break;
    case 's':
      glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); // Point
      glutPostRedisplay();
      break;
    case 'd':
      glEnable(GL_DEPTH_TEST);  // Avec tampon de profondeur
      glutPostRedisplay();
      break;
    case 'D':
      glDisable(GL_DEPTH_TEST); // Sans tampon de profondeur
      glutPostRedisplay();
      break;
    case 'q':                   // Quitter
	  //close(0);
      break;
  }
}
 
//----------------------------------------------------------------------
// AFFICHAGE : dessine la forme
//----------------------------------------------------------------------
void display(){
  int i, j;
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Reset + double tampon
  for(i = 0; i < 6; i++) {                // Pour chaque face
    glBegin(GL_POLYGON);                  // On dessine un nouveau polygone
    for(j = 0; j < 4; j++) {              // Pour chaque sommet
      glColor3f(p[f[i][j]].r, p[f[i][j]].g, p[f[i][j]].b);
      glVertex3f(p[f[i][j]].x, p[f[i][j]].y, p[f[i][j]].z);
    }
    glEnd();                              // Fin du Polygone
  }
 
  glFlush();                              // On force l'affichage
 
  glLoadIdentity();                       // On initialise la matrice de translation
  //gluLookAt(-1.0,0.0,5.0,0.0,0.0,0.0,0.0,1.0,0.0);
  glRotatef(-anglex, 0.0, 1.0, 0.0);      // pour faire des rotation
  glRotatef(-angley, 1.0, 0.0, 0.0);
 
  glutSwapBuffers();
}
 
//----------------------------------------------------------------------
// MOUSE : récupère les évènements souris
//----------------------------------------------------------------------
void mouse(int button, int state, int x, int y){
  // Si on appuie sur le bouton gauche
  if(button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
    presse = 1; // Le booléen passe devient vrai
    xold = x;   // On sauvegarde la position
    yold = y;
  }
  // Si on relache le bouton
  if(button == GLUT_LEFT_BUTTON && state == GLUT_UP) presse = 0;
}
 
//----------------------------------------------------------------------
// MOUSEOPTION : effectue la rotation
//----------------------------------------------------------------------
void mousemotion(int x, int y) {
  if(presse == 1) {				// Si le bouton est pressé
    anglex = anglex + (x-xold); // On modifie la position actuelle de la souris
    angley = angley + (y-yold); // en fonction de la position actuelle de la
    glutPostRedisplay();        // souris et de la dernière sauvegarde
  }
  xold = x; // On sauvegarde la position actuelle de la souris
  yold = y;
}
 
//----------------------------------------------------------------------
// RESHAPE : Redimentionnement de la fenêtre
//----------------------------------------------------------------------
void reshape(int x, int y) {
  if(x < y) glViewport(0, (y-x)/2, x, x);
  if(y < x) glViewport((x-y)/2, 0, y, y);
}
Cet article a été publié dans C / C++, OpenGL avec les mots-clefs , , , , , , . Bookmarker le permalien. Laisser un commentaire ou faire un trackback : URL de trackback.

7 Commentaires

  1. romain
    Publié le 11 mars 2009 à 16 h 39 min | Permalien

    tu as aussi une fonction spéciale pour tracer un cube.

  2. neilaur
    Publié le 18 mars 2009 à 14 h 01 min | Permalien

    Merci pour ce tutoriel bref mais utile

  3. Anaïs
    Publié le 6 avril 2009 à 16 h 55 min | Permalien

    Merci, ce qu’on galère quand c’est pas documenté !

  4. jean pierre
    Publié le 12 janvier 2010 à 9 h 55 min | Permalien

    Merci pour ce mini tuto cependant j ai une petite question bête .j’utlise bien le

    MacBook-Pro-de-jean-pierre-Bias:etude jeanpierrebias$ gcc -framework GLUT -framework OpenGL -framework Cocoa cube.c -o cube

    MacBook-Pro-de-jean-pierre-Bias:etude jeanpierrebias$ cube
    -bash: cube: command not found

    MacBook-Pro-de-jean-pierre-Bias:etude jeanpierrebias$ – cube
    -bash: -: command not found

    une fois compilé quelle commande faut-il entrer pour afficher le cube ?

  5. Le Noob
    Publié le 13 octobre 2010 à 19 h 03 min | Permalien

    Merci beaucoup, beaucoup =D C’est le premier tuto que je trouve qui fait fonctionner opengl sur mac chez moi =)

  6. Publié le 13 novembre 2015 à 12 h 00 min | Permalien

    At last! Someone with the insight to solve the prbolem!

Laisser un commentaire

Votre e-mail ne sera jamais publié ni communiqué. Les champs obligatoires sont indiqués par *

Vous pouvez utiliser ces balises et attributs HTML <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

*
*

  • Flux RSS Nico dev'blog