OpenGL/glut

[Premium]

Salut,

Est-ce que quelqu'un pourrait m'indiquer un cours qu'il a testé sur OpenGL et qui lui a permis de bien comprendre.

Ainsi que des exos avec solution.

Merci

[Sentinel]

http://nehe.gamedev.net/

[tsubasaleguedin]

http://nehe.gamedev.net/

nehe est un bon debut, mais pas suffisant pour reellement comprendre les principes des matrices pour les camera et lumiere.

Car c'est pas aussi simple que ca en a l'air, enfin ya des specificité.

Par exemple si j'attache une camera a une matrice pour un point de vue, et que je rotate ma matrice, la camera rotate aussi :). Ca peut surprendre.

Donc pour moi nehe c'est bien pour les bases ( surtout les exemples multi langages ), mais surtout pour reellement comprendre certain principe de base de opengl, rien de tel que le site opengl en lui meme.

http://www.opengl.org/wiki/index.php/Main_Page

http://www.opengl.org/code/

http://www.opengl.org/code/category/C22

http://www.opengl.org/code/category/C18

Voila, en bref :

- D'abord cefamiliariser avec opengl sur nehe gamedev

- Ensuite valider ses connaissances et appronfondir les effets opengl sur le site opengl

[lorinc]

nehe c'est quand même magique pour commencer à prendre en main le biniou et avoir des exemples concrets sous la main

[Premium]

J'ai pris quelques sources fournit à la fin de chaque cours dans Nehe.

Je télécharge les sources pour linux.

Quand je lance make pas de souci mais lorsque lance l'executable, j'ai toujours ce message :

lesson1: freeglut_window.c:300: fgOpenWindow: Assertion `window->Window.VisualInfo != ((void *)0)' failed.
Abandon

[tsubasaleguedin]

J'ai pris quelques sources fournit à la fin de chaque cours dans Nehe.

Je télécharge les sources pour linux.

Quand je lance make pas de souci mais lorsque lance l'executable, j'ai toujours ce message :

lesson1: freeglut_window.c:300: fgOpenWindow: Assertion `window->Window.VisualInfo != ((void *)0)' failed.
Abandon

Perso je n'utilise pas GLUT qui ma un peu soulé, je prefere utiliser un tool kit comme GTK ou QT, puis je creer mon contexte openGL et ensuite je fais de l'openGL classque dans le contexte.

Par exemple en GTK j'utilise gtkglext. Si tu tiens dans l'immediat a utiliser GLUT j'ai du code ici qui marche.

#include <GL/gl.h>	// Header File For The OpenGL32 Library
#include <GL/glu.h>	// Header File For The GLu32 Library
#include <GL/glut.h>	// Header File For The GLu32 Library
#include <unistd.h>	 // Header file for sleeping.
#include <stdio.h>	  // Header file for standard file i/o.
#include <stdlib.h>	 // Header file for malloc/free.

/* ascii codes for various special keys */
#define ESCAPE 27
#define PAGE_UP 73
#define PAGE_DOWN 81
#define UP_ARROW 72
#define DOWN_ARROW 80
#define LEFT_ARROW 75
#define RIGHT_ARROW 77

/* The number of our GLUT window */
int window; 

/* lighting on/off (1 = on, 0 = off) */
int light;

/* L pressed (1 = yes, 0 = no) */
int lp;

/* F pressed (1 = yes, 0 = no) */
int fp;


GLfloat xrot;   // x rotation 
GLfloat yrot;   // y rotation 
GLfloat xspeed; // x rotation speed
GLfloat yspeed; // y rotation speed

GLfloat z=-5.0f; // depth into the screen.

/* white ambient light at half intensity (rgba) */
GLfloat LightAmbient[] = { 0.5f, 0.5f, 0.5f, 1.0f };

/* super bright, full intensity diffuse light. */
GLfloat LightDiffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };

/* position of light (x, y, z, (position of light)) */
GLfloat LightPosition[] = { 0.0f, 0.0f, 2.0f, 1.0f };

GLuint	filter;			/* Which Filter To Use (nearest/linear/mipmapped) */
GLuint	texture[3];		/* Storage for 3 textures. */

/* Image type - contains height, width, and data */
struct Image {
unsigned long sizeX;
unsigned long sizeY;
char *data;
};
typedef struct Image Image;

// quick and dirty bitmap loader...for 24 bit bitmaps with 1 plane only.  
// See http://www.dcs.ed.ac.uk/~mxr/gfx/2d/BMP.txt for more info.
// if mesa ever gets glaux, let me know.
int ImageLoad(char *filename, Image *image) {
FILE *file;
unsigned long size;				 // size of the image in bytes.
unsigned long i;					// standard counter.
unsigned short int planes;		  // number of planes in image (must be 1) 
unsigned short int bpp;			 // number of bits per pixel (must be 24)
char temp;						  // used to convert bgr to rgb color.

// make sure the file is there.
if ((file = fopen(filename, "rb"))==NULL)
{
printf("File Not Found : %s\n",filename);
return 0;
}

// seek through the bmp header, up to the width/height:
fseek(file, 18, SEEK_CUR);

// read the width
if ((i = fread(&image->sizeX, 4, 1, file)) != 1) {
printf("Error reading width from %s.\n", filename);
return 0;
}
printf("Width of %s: %lu\n", filename, image->sizeX);

// read the height 
if ((i = fread(&image->sizeY, 4, 1, file)) != 1) {
printf("Error reading height from %s.\n", filename);
return 0;
}
printf("Height of %s: %lu\n", filename, image->sizeY);

// calculate the size (assuming 24 bits or 3 bytes per pixel).
size = image->sizeX * image->sizeY * 3;

// read the planes
if ((fread(&planes, 2, 1, file)) != 1) {
printf("Error reading planes from %s.\n", filename);
return 0;
}
if (planes != 1) {
printf("Planes from %s is not 1: %u\n", filename, planes);
return 0;
}

// read the bpp
if ((i = fread(&bpp, 2, 1, file)) != 1) {
printf("Error reading bpp from %s.\n", filename);
return 0;
}
if (bpp != 24) {
printf("Bpp from %s is not 24: %u\n", filename, bpp);
return 0;
}

// seek past the rest of the bitmap header.
fseek(file, 24, SEEK_CUR);

// read the data. 
image->data = (char *) malloc(size);
if (image->data == NULL) {
printf("Error allocating memory for color-corrected image data");
return 0;	
}

if ((i = fread(image->data, size, 1, file)) != 1) {
printf("Error reading image data from %s.\n", filename);
return 0;
}

for (i=0;i<size;i+=3) { // reverse all of the colors. (bgr -> rgb)
temp = image->data[i];
image->data[i] = image->data[i+2];
image->data[i+2] = temp;
}

// we're done.
return 1;
}

// Load Bitmaps And Convert To Textures
GLvoid LoadGLTextures(GLvoid) {	
// Load Texture
Image *image1;

// allocate space for texture
image1 = (Image *) malloc(sizeof(Image));
if (image1 == NULL) {
printf("Error allocating space for image");
exit(0);
}

if (!ImageLoad("crate.bmp", image1)) {
exit(1);
}		

// Create Textures	
glGenTextures(3, &texture[0]);

// texture 1 (poor quality scaling)
glBindTexture(GL_TEXTURE_2D, texture[0]);   // 2d texture (x and y size)

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST); // cheap scaling when image bigger than texture
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST); // cheap scaling when image smalled than texture

// 2d texture, level of detail 0 (normal), 3 components (red, green, blue), x size from image, y size from image, 
// border 0 (normal), rgb color data, unsigned byte data, and finally the data itself.
glTexImage2D(GL_TEXTURE_2D, 0, 3, image1->sizeX, image1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, image1->data);

// texture 2 (linear scaling)
glBindTexture(GL_TEXTURE_2D, texture[1]);   // 2d texture (x and y size)
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // scale linearly when image bigger than texture
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // scale linearly when image smalled than texture
glTexImage2D(GL_TEXTURE_2D, 0, 3, image1->sizeX, image1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, image1->data);

// texture 3 (mipmapped scaling)
glBindTexture(GL_TEXTURE_2D, texture[2]);   // 2d texture (x and y size)
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // scale linearly when image bigger than texture
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST); // scale linearly + mipmap when image smalled than texture
glTexImage2D(GL_TEXTURE_2D, 0, 3, image1->sizeX, image1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, image1->data);

// 2d texture, 3 colors, width, height, RGB in that order, byte data, and the data.
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, image1->sizeX, image1->sizeY, GL_RGB, GL_UNSIGNED_BYTE, image1->data); 
};

/* A general OpenGL initialization function.  Sets all of the initial parameters. */
GLvoid InitGL(GLsizei Width, GLsizei Height)	// We call this right after our OpenGL window is created.
{
LoadGLTextures();						   // load the textures.
glEnable(GL_TEXTURE_2D);					// Enable texture mapping.

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);	// This Will Clear The Background Color To Black
glClearDepth(1.0);				// Enables Clearing Of The Depth Buffer
glDepthFunc(GL_LESS);			// The Type Of Depth Test To Do
glEnable(GL_DEPTH_TEST);			// Enables Depth Testing
glShadeModel(GL_SMOOTH);			// Enables Smooth Color Shading

glMatrixMode(GL_PROJECTION);
glLoadIdentity();				// Reset The Projection Matrix

gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);	// Calculate The Aspect Ratio Of The Window

glMatrixMode(GL_MODELVIEW);

// set up light number 1.
glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);  // add lighting. (ambient)
glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);  // add lighting. (diffuse).
glLightfv(GL_LIGHT1, GL_POSITION,LightPosition); // set light position.
glEnable(GL_LIGHT1);							 // turn light 1 on.
}

/* The function called when our window is resized (which shouldn't happen, because we're fullscreen) */
GLvoid ReSizeGLScene(GLsizei Width, GLsizei Height)
{
if (Height==0)				// Prevent A Divide By Zero If The Window Is Too Small
Height=1;

glViewport(0, 0, Width, Height);		// Reset The Current Viewport And Perspective Transformation

glMatrixMode(GL_PROJECTION);
glLoadIdentity();

gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);
glMatrixMode(GL_MODELVIEW);
}

/* The main drawing function. */
GLvoid DrawGLScene(GLvoid)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);		// Clear The Screen And The Depth Buffer
glLoadIdentity();				// Reset The View

glTranslatef(0.0f,0.0f,z);				  // move z units out from the screen.

glRotatef(xrot,1.0f,0.0f,0.0f);		// Rotate On The X Axis
glRotatef(yrot,0.0f,1.0f,0.0f);		// Rotate On The Y Axis

glBindTexture(GL_TEXTURE_2D, texture[filter]);   // choose the texture to use.

glBegin(GL_QUADS);						// begin drawing a cube

// Front Face (note that the texture's corners have to match the quad's corners)
glNormal3f( 0.0f, 0.0f, 1.0f);							  // front face points out of the screen on z.
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);	// Bottom Left Of The Texture and Quad
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);	// Bottom Right Of The Texture and Quad
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);	// Top Right Of The Texture and Quad
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);	// Top Left Of The Texture and Quad

// Back Face
glNormal3f( 0.0f, 0.0f,-1.0f);							  // back face points into the screen on z.
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);	// Bottom Right Of The Texture and Quad
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);	// Top Right Of The Texture and Quad
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);	// Top Left Of The Texture and Quad
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);	// Bottom Left Of The Texture and Quad

// Top Face
glNormal3f( 0.0f, 1.0f, 0.0f);							  // top face points up on y.
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);	// Top Left Of The Texture and Quad
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,  1.0f,  1.0f);	// Bottom Left Of The Texture and Quad
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,  1.0f,  1.0f);	// Bottom Right Of The Texture and Quad
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);	// Top Right Of The Texture and Quad

// Bottom Face	   
glNormal3f( 0.0f, -1.0f, 0.0f);							 // bottom face points down on y. 
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);	// Top Right Of The Texture and Quad
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);	// Top Left Of The Texture and Quad
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);	// Bottom Left Of The Texture and Quad
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);	// Bottom Right Of The Texture and Quad

// Right face
glNormal3f( 1.0f, 0.0f, 0.0f);							  // right face points right on x.
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);	// Bottom Right Of The Texture and Quad
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);	// Top Right Of The Texture and Quad
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);	// Top Left Of The Texture and Quad
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);	// Bottom Left Of The Texture and Quad

// Left Face
glNormal3f(-1.0f, 0.0f, 0.0f);							  // left face points left on x.
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);	// Bottom Left Of The Texture and Quad
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);	// Bottom Right Of The Texture and Quad
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);	// Top Right Of The Texture and Quad
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);	// Top Left Of The Texture and Quad

glEnd();									// done with the polygon.

xrot+=xspeed;						// X Axis Rotation	
yrot+=yspeed;						// Y Axis Rotation

// since this is double buffered, swap the buffers to display what just got drawn.
glutSwapBuffers();
}


/* The function called whenever a normal key is pressed. */
void keyPressed(unsigned char key, int x, int y) 
{
/* avoid thrashing this procedure */
usleep(100);

switch (key) {	
case ESCAPE: // kill everything.
/* shut down our window */
glutDestroyWindow(window); 

/* exit the program...normal termination. */
exit(1);				   	
break; // redundant.

case 76: 
case 108: // switch the lighting.
printf("L/l pressed; light is: %d\n", light);
light = light ? 0 : 1;			  // switch the current value of light, between 0 and 1.
printf("Light is now: %d\n", light);
if (!light) {
	glDisable(GL_LIGHTING);
} else {
	glEnable(GL_LIGHTING);
}
break;

case 70:
case 102: // switch the filter.
printf("F/f pressed; filter is: %d\n", filter);
filter+=1;
if (filter>2) {
	filter=0;	
}	
printf("Filter is now: %d\n", filter);
break;

default:
break;
}	
}

/* The function called whenever a normal key is pressed. */
void specialKeyPressed(int key, int x, int y) 
{
/* avoid thrashing this procedure */
usleep(100);

switch (key) {	
case GLUT_KEY_PAGE_UP: // move the cube into the distance.
z-=0.02f;
break;

case GLUT_KEY_PAGE_DOWN: // move the cube closer.
z+=0.02f;
break;

case GLUT_KEY_UP: // decrease x rotation speed;
xspeed-=0.01f;
break;

case GLUT_KEY_DOWN: // increase x rotation speed;
xspeed+=0.01f;
break;

case GLUT_KEY_LEFT: // decrease y rotation speed;
yspeed-=0.01f;
break;

case GLUT_KEY_RIGHT: // increase y rotation speed;
yspeed+=0.01f;
break;

default:
break;
}	
}

int main(int argc, char **argv) 
{  
/* Initialize GLUT state - glut will take any command line arguments that pertain to it or 
   X Windows - look at its documentation at http://reality.sgi.com/mjk/spec3/spec3.html */  
glutInit(&argc, argv);  

/* Select type of Display mode:   
 Double buffer 
 RGBA color
 Alpha components supported 
 Depth buffer */  
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH);  

/* get a 640 x 480 window */
glutInitWindowSize(640, 480);  

/* the window starts at the upper left corner of the screen */
glutInitWindowPosition(0, 0);  

/* Open a window */  
window = glutCreateWindow("Jeff Molofee's GL Code Tutorial ... NeHe '99");  

/* Register the function to do all our OpenGL drawing. */
glutDisplayFunc(&DrawGLScene);  

/* Go fullscreen.  This is as soon as possible. */
glutFullScreen();

/* Even if there are no events, redraw our gl scene. */
glutIdleFunc(&DrawGLScene);

/* Register the function called when our window is resized. */
glutReshapeFunc(&ReSizeGLScene);

/* Register the function called when the keyboard is pressed. */
glutKeyboardFunc(&keyPressed);

/* Register the function called when special keys (arrows, page down, etc) are pressed. */
glutSpecialFunc(&specialKeyPressed);

/* Initialize our window. */
InitGL(640, 480);

/* Start Event Processing Engine */  
glutMainLoop();  

return 1;
}

Je le compile comme ca pour avoir l'obj

gcc -Wall -Wfatal-errors -c -o testogl.o testogl.c

Et je link l'obj comme ca pour avoir le binaire:

gcc -o  testogl lesson7.o -lglut -lGL -lGLU

Normalement tu a un executable apres qui est testogl.

Voici la texture a mettre dans le repertoire :

http://linuxonfire.free.fr/lol/crate.bmp

Ce qui devrait te donner un truc comme ca :

En clair GLUT sert a gerer la creation de la fenetre et les evenements de celle ci ( clavier, souris toussa ). Donc la seul chose qui change si t'utilise GLUT, GTK, QT ou autre et la creation de la fenetre et le "management" des evenements externe a la scene opengl.

Tout le code de dessin ( generalement le On Draw) et son initialisation ( Init & configure ) sont portable d'un toolkit a l'autre, j'ai moi meme utiliser des exemple GLUT que j'ai reporté en GTK sans probleme :)

[Premium]

En compilant comme tu l'as fait avec le code donné, j'ai toujours ce message :

./testogl
testogl: freeglut_window.c:300: fgOpenWindow: Assertion `window->Window.VisualInfo != ((void *)0)' failed.
Abandon

[tsubasaleguedin]

En compilant comme tu l'as fait avec le code donné, j'ai toujours ce message :

./testogl
testogl: freeglut_window.c:300: fgOpenWindow: Assertion `window->Window.VisualInfo != ((void *)0)' failed.
Abandon

Ta quoi comme distrib linux .?

[Premium]

Ta quoi comme distrib linux .?

Ubuntu

[lorinc]

tu as la 3d au moins de manière logicielle (avec mesa) au mieux en hard ?

[Premium]

tu as la 3d au moins de manière logicielle (avec mesa) au mieux en hard ?

J'ai pas saisi la question

J'ai codé un cube en 3D avec OpenGL et ça fonctionnait mais pour l'exemple donné ainsi que ceux de nehe, me donne une erreur à l'execution

[msking]

salut

j'ai un cour d'openGl trés intéssant!!!!!!!!!!!!!!!!

Envoi moi ton @mail sur

"smaalimaher@yahoo.fr"

[msking]

j'ai un code d'un cube tournant :

#include<GL/glut.h>
typedef struct 
{
float x;
float y;
float z; //coordonnées de point 
float r;
float g;
float b; //couleurs du point
} point;

//les points composant le cube
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}

};
//stockage des faces du cube
int f[6][4]= 
{
 {0,1,2,3},
 {6,7,3,2},
 {4,5,6,7},
 {0,1,5,4},
 {1,5,6,2},
 {0,4,7,3}
};

int anglex,angley,x,y,xold,yold;
char presse;
//protocol des fonctions
void affichage();
void clavier(unsigned char touche,int x,int y);
void reshape(int x,int y);
void idle();
void mouse(int bouton,int etat,int x,int y);
void mousemotion(int x,int y);
int main(int argc,char **argv)
{   
 /*initialisation de glut et création de la fenetre*/
 glutInit(&argc,argv);
 glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE|GLUT_DEPTH);
 glutInitWindowPosition(200,200);
 glutInitWindowSize(500,500);
 glutCreateWindow("cube");
 /*inialisation de openGL */
 glClearColor(0.0,0.0,0.0,0.0);
 glColor3f(1.0,1.0,1.0);
 glPointSize(2.0);
 glEnable(GL_DEPTH_TEST);

 /*enregistrement des fonctions */
 glutDisplayFunc(affichage);
 glutKeyboardFunc(clavier);
 glutReshapeFunc(reshape);
 glutMouseFunc(mouse);
 glutMotionFunc(mousemotion);
 /*Entree dans la boucle principale glut */
 glutMainLoop();
 return 0;
}
void affichage()
{
 /*effacement de l'image avec couleur de fond*/
 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
 glLoadIdentity();
 glRotatef(-angley,1.0,0.0,0.0);
 glRotatef(-anglex,0.0,1.0,0.0);
 /* dessiner le cube */
 for(int i=0;i<6;i++)
 {
	 glBegin(GL_POLYGON);
	 for(int j=0;j<4;j++)
	 {
		 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();	
 }	
 glFlush();
 /*On echange les buffers */
 glutSwapBuffers();
}
void clavier(unsigned char touche,int x,int y)
{switch(touche)
{case 'p':/*affichage du carre plein*/
  glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
  glutPostRedisplay();
  break;
case 'f':/* affichage en mode fil de fer*/
  glPolygonMode(GL_FRONT_AND_BACK,GL_LINE); 
  glutPostRedisplay();  
  break;
case 's':/*affichage en mode sommet seul */
	 glPolygonMode(GL_FRONT_AND_BACK,GL_POINT); 
	 glutPostRedisplay();
	 break;
case 'd':
	 glEnable(GL_DEPTH_TEST);
	 glutPostRedisplay();
	 break;
case 'D':
	 glDisable(GL_DEPTH_TEST);
	 glutPostRedisplay();
	 break;
 case 'q':/* quitter program */
   exit(0);
   }
   }	   
 void reshape(int x,int y)
 {
  if(x<y)
  glViewport(0,(y-x)/2,x,x);
  else
  glViewport((x-y)/2,0,y,y);
 }	
 void mouse(int button,int state,int x,int y)
 {
  /* si on appuie sur le boutton gauche*/
  if(button==GLUT_LEFT_BUTTON && state==GLUT_DOWN)
  {
	   presse = 1; /* le booleen presse passe a 1(vrai) */
	  xold=x;
	  yold=y;
  }   
  /* Si on relache le bouitton gauch */
  if(button==GLUT_LEFT_BUTTON && state==GLUT_UP)
   presse = 0;
 }	
 void mousemotion(int x,int y)
 {
  if(presse) 
  {
	  anglex=anglex+(x-xold);
	  angley=angley+(y-yold);
	  glutPostRedisplay(); /* refresh */

  }   
  xold=x;
  yold=y;
 }

ce code est compilé et executer d'avance

msking

- edit de Quarky -

Ajout des balises

 : c'est plus propre