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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
//***************************************************************************************
// TP OPENGL
// Groupe ICAR
//***************************************************************************************
//Objectif:
//--------
//Comprendre la gestion de l’affichage de OpenGL
//Effectuer des transformations géométriques complexes
//Réalisation d'une animation 3D
//
//Travail à faire:
//----------------
//En vous aidant de la documentation:
//- Modifier l'exemple pour que la projection soit en perspective au lieu de parallèle. Quel(s) paramètre(s) de quelle(s) fonction(s) faut-il modifier ?
//- Appliquer des transformations géométriques au cube
//o Une rotation
//o Une translation
//- Faire tourner le cube autour de l'origine (servez-vous des variables définies)
//- Créer une autre primitive (un autre objet), au choix. Que se passe-t-il ? Pourquoi ?
//- Appliquer une translation et/ou une rotation sur la deuxième primitive. Que se passe-t-il ? Pourquoi ?
//- Faire tourner les primitives indépendamment l’une de l’autre (voir fonction glPushMatrix() et glPopMatrix())
//
//***************************************************************************************
#include "glut.h"
#include "glu.h"
#include "glaux.h"
#include <stdlib.h>
// variables de la lumière
float LightPos[4] = {0.0,0.0,0.0,0.5};
float ambient[] = {1.0,1.0,0.0,1.0};
// distances des planetes par rapport au soleil
float dTerre=0.1;
float dLune=0.05;
float diamSoleil=0.5;
float diamTerre=0.3;
float diamLune=0.2;
float angle1 =0.0;
float angle2 =0.0;
float angle3 =0.0;
unsigned texture_terre[1];
AUX_RGBImageRec *texture1;
void init(void)
{
texture1 = auxDIBImageLoad("test.bmp");
// initialise la buffer ou va etre rendu la scene
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
// initialisation de la fenetre (taille 500x500)
// glutInitWindowSize (500, 500);
// on positionne la fenetre sur l'ecran
// glutInitWindowPosition (0, 0);
// on cree la fenetre
glutCreateWindow ("Premier pas en OpenGL de Mickaël GUEPE...");
// couleur de remplissage lors de l'effacement du buffer
glClearColor (0.0, 0.0, 0.0, 0.0);
// model d'eclairage
glShadeModel (GL_FLAT);
glEnable (GL_TEXTURE_2D);
glutFullScreen();
}
void dessineAxe(float d) {
glColor3f (1.0, 1.0, 1.0);
glutWireTorus(0.0,d,100,100);
}
void dessineSoleil() {
glColor3f (1.0, 1.0, 0.0);
glutSolidSphere(0.01,100.0,100.0);
}
void dessineTerre() {
glColor3f (0.0, 0.0, 1.0);
glutSolidSphere(0.01,100.0,100.0);
}
void dessineLune() {
glColor3f (0.0, 1.0, 1.0);
glutSolidSphere(0.01,100.0,100.0);
}
void dessineGluSphere() {
glGenTextures(1, &texture_terre[0]);
glBindTexture(GL_TEXTURE_2D, texture_terre[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, 3, texture1->sizeX, texture1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, texture1->data);
GLUquadric *quad=gluNewQuadric();
gluSphere(quad, 0.01, 100.0, 100.0);
}
void display(void) // affichage de la fenetre
{
(angle1 == 360.0)? angle1=0.0 : angle1+=0.2;
(angle2 == 360.0)? angle2=0.0 : angle2+=0.4;
(angle3 == 360.0)? angle3=0.0 : angle3+=2.5;
glClear (GL_COLOR_BUFFER_BIT);
//*****************************************************************************
// Gestion de la lumière
glEnable(GL_CULL_FACE); //active suppression des faces cachées
glEnable(GL_SMOOTH); //lissage
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
glLightfv(GL_LIGHT0,GL_POSITION, LightPos);
glLoadIdentity();//1
gluLookAt(0.25,0.125,0.25, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
// axes de rotations des planetes
dessineAxe(dTerre);
// Planetes
glRotatef(angle1, 0.0, 0.0, 1.0);
dessineSoleil();
glPushMatrix();
glRotatef(angle3, 0.0, 0.0, 1.0);
glTranslatef(dLune,0,0);
dessineGluSphere();
glPopMatrix();
glPushMatrix();
glRotatef(angle2, 0.0, 0.0, 1.0);
glTranslatef(dTerre,0,0);
dessineTerre();
glPushMatrix();
glRotatef(angle3, 0.0, 0.0, 1.0);
glTranslatef(dLune,0,0);
dessineLune();
glPopMatrix();
glPopMatrix();
//*****************************************************
glutSwapBuffers();
glutPostRedisplay();
}
void reshape (int width,int heigth) //mise a jour de la fenetre
{
//*****************************************************************************
// A vous ;-)))
//
glViewport(0,0,width,heigth);//1
glMatrixMode(GL_PROJECTION);//1
// glLoadIdentity();//1
gluPerspective(45, width/heigth, 0, 100);//1
glMatrixMode(GL_MODELVIEW);//1
//*****************************************************************************
}
// fonction de gestion du clavier
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 'q': // la touche 'q' ou
case 'Q': // 'Q'
case 27 :
exit(0);
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
// on initialise la scene
init ();
// definition des fonctions "callback"
// les 3 fonctions qui suivent permettent d'indiquer les fonctions a utilisé :
// lors de l'affichage
glutDisplayFunc(display);
// lors du redimensionnement de la fentre
glutReshapeFunc(reshape);
// lors d'un appui sur un touche du clavier
glutKeyboardFunc(keyboard);
// la librairie glut gere elle meme la boucle d'evenement
glutMainLoop();
return 0;
} |
