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
4
#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
</glut></opengl></opengl>

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
172
//----------------------------------------------------------------------
// 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(&amp;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 &lt; 6; i++) {                // Pour chaque face
    glBegin(GL_POLYGON);                  // On dessine un nouveau polygone
    for(j = 0; j &lt; 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 &amp;&amp; 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 &amp;&amp; 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 &lt; y) glViewport(0, (y-x)/2, x, x);
  if(y &lt; x) glViewport((x-y)/2, 0, y, y);
}
</glut></opengl></opengl></stdlib.h></gl>
Cet article a été publié dans C / C++, OpenGL avec les mots-clefs , , , , , , . Bookmarker le permalien. Les commentaires et les trackbacks sont fermés.

7 Commentaires