quand je fait tourner ma sphère, elle ne tourne pas selon  
un axe global mais local, or je voudrais que ce soit selon  
le repère global, et j'ai essayé des trucs avec  
glPopMatrix et glPushMatrix mais ça donne des trucs  
bizarres. vous ne sauriez pas comment faire par hasard ?
 
PS : ça marche avec le clavier.
 
void display ()
{
 static GLfloat tableau_entrelace [24][3] = {{1.0,  
1.0, 1.0}, {-X, 0.0, Z}, {1.0, 1.0, 1.0}, {X, 0.0, Z},  
 {1.0, 1.0, 1.0}, {-X, 0.0, -Z}, {1.0, 1.0, 1.0},  
{X, 0.0, -Z}, {1.0, 1.0, 1.0}, {0.0, Z, X},
 {1.0, 1.0, 1.0}, {0.0, Z, -X}, {1.0, 1.0, 1.0},  
{0.0, -Z, X}, {1.0, 1.0, 1.0}, {0.0, -Z, -X},  
 {1.0, 1.0, 1.0}, {Z, X, 0.0}, {1.0, 1.0, 1.0}, {-
Z, X, 0.0}, {1.0, 1.0, 1.0}, {Z, -X, 0.0},  
 {1.0, 1.0, 1.0}, {-Z, -X, 0.0} }; //ceci est  
un tableau entrelacé de couleurs et de coordonnées de  
sommets
 
 glInterleavedArrays (GL_C3F_V3F, 0,  
tableau_entrelace) ; //lecture dans le tableau entrelacé
 
/*definition des polygones par le numéro des sommets*/
 
 static GLuint indices [20][3]=  
{1,4,0,4,9,0,4,5,9,8,5,4,1,8,4,1,10,8,10,3,8,8,3,5,3,2,5,
 
 3,7,2,3,10,7,10,6,7,6,11,7,6,0,11,6,1,0,10,1,6,11,0
,9,2,11,9,5,2,9,11,2,7};  
 
 glPolygonMode (GL_FRONT, GL_LINE) ; //la face  
avant des polygones sera rendue en fil de fer
 glFrontFace (GL_CCW) ;    
 //spécifie la face avant
 glEnable (GL_CULL_FACE) ;    
  glCullFace (GL_BACK) ;  
 //suppression des faces arrières
   
   
   
  glClear( GL_COLOR_BUFFER_BIT |  
GL_DEPTH_BUFFER_BIT );
  glPushMatrix () ;
  glRotatef ( nbr_degre, j, k, l ) ;  
   
 
  for (GLint i= 0 ; i<20 ;i++)  
  {  
   
  subdivision (&tableau_entrelace [indices[i]
[0]*2+1][0], &tableau_entrelace [indices[i][1]*2+1][0],  
&tableau_entrelace [indices[i][2]*2+1][0]); //sudivise et  
affiche la sphère
  }
  glPopMatrix () ;
 
glutSwapBuffers() ; //permutte le back buffer avec le  
front buffer
glFlush () ;  
 
}
 
 
void reshape (int w, int h)
{
 glViewport (0, 0, w, h) ;
 glMatrixMode (GL_PROJECTION) ;
 glLoadIdentity () ;
 glFrustum(-10.0 , 10.0, -7.5, 7.5, 15.0, 100.0);
 glMatrixMode(GL_MODELVIEW); //la matrice active de  
modelisation/visualisation sera affectée
 glLoadIdentity();   //charge  
la matrice identité
 
 gluLookAt (0.0, 0.0, 25.0, 0.0,0.0,0.0, 0.0, 1.0,  
0.0) ; //caméra placée sur l'axe des Z et regardant vers  
l'origine
}
 
 
void keyboard (unsigned char key, int x, int y)
{
 
 
 
 switch (key)  
 {
 case 'd' : //fait tourner selon l'axe des Y
 case 'D' :
   nbr_degre = 4.0;
   j = 0.0 ;
   k = 1.0 ;
   l = 0.0 ;
  glutPostRedisplay () ;
  break ;
 
 case 's' :
 case 'S' :
  nbr_degre = 4.0; //fait tourner selon  
l'axe des -Y
   j = 0.0 ;
   k = -1.0 ;
   l = 0.0 ;
   glutPostRedisplay () ;
   break ;
 
 case 'e' : //fait tourner selon l'axe des X
 case 'E' :
  nbr_degre = 4.0;
   j = -1.0 ;
   k = 0.0 ;
   l = 0.0 ;
   glutPostRedisplay () ;
   break ;
 
 case 'x' : //fait tourner selon l'axe des X
 case 'X' :
  nbr_degre = 4.0;
   j = 1.0 ;
   k = 0.0 ;
   l = 0.0 ;
   glutPostRedisplay () ;
   break ;
 
 }
}

on est censé comprendre ?
 
sous opengl, tu as trois matrices : une pour les coordonnées de texture (pas important ici), une pour la projection (idem), une pour transformer l'objet courant dans le repère vue (repère caméra).  
 
donc :
 
tu as au minimum une matrice qui tranforme le repère monde dans le repère caméra : c'est la matrice modelview.
 
si tu veux faire tourner un objet dans ce repère caméra, tu appliques (multiplie) sa matrice à la matrice caméra, et tu la mets en modelview. (matrice caméra * matrice objet)
 
si tu veux faire tourner l'objet sur lui-même (repère local), tu fais l'inverse (matrice objet * matrice caméra).

en ligne de code, c quoi la matrice caméra et c quoi la matrices objet ? s'te plaît  

me souviens plus. si tu as une classe matrice, c'est plus simple ().
 
modelview est la matrice appliquée à un objet pour le transformer dans le repère caméra. ensuite, il est projeté puis affiché.  
 
c'est beaucoup plus pratique sous directx car tu as une matrice pour l'objet et une matrice pour la caméra. tu peux noter ces matrices comme :
 
localToWorld (passer du repère local au repère monde)
worldToCamera (passer du repère monde au repère caméra)
 
multiplier ces deux matrices te donnera "l'équivalent" opengl :
localToWorld * worldToCamera = localToCamera = modelview.
 
comme je n'ai toujours pas compris ce que tu veux faire, je ne sais pas trop comment t'aider. je pense que tu veux faire tourner l'objet sur lui-même, il faut alors changer la matrice localToWorld puis la multiplier par worldToCamera.
 
par exemple si tu as une jolie classe matrice et que tu veux que l'objet tourne autour de lui-même :
 
Matrix localToWorld;
localToWorld.rotateX(angle);
Matrix worldToCamera = computeCameraMatrix(); // l'équivalent de gluLookAt();
Matrix localToCamera = localToWorld * worldToCamera;
 
glMatrixMode(modelview);
glLoadMatrix(&localToCamera);
 
tu devrais chercher un cours sur les repères ou regarder l'aide de directx. à la base c'est pas très compliqué, mais ça peut être dur à digérer.